You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1050 lines
35 KiB
1050 lines
35 KiB
using System; |
|
using System.Collections.Generic; |
|
using System.Text; |
|
using ESRI.ArcGIS.Geodatabase; |
|
using ESRI.ArcGIS.Carto; |
|
using System.Runtime.InteropServices; |
|
using ESRI.ArcGIS.Geometry; |
|
using System.IO; |
|
using KGIS.Framework.Utils; |
|
|
|
|
|
namespace Kingo.Plugin.MakeTaskPackage.Entity |
|
{ |
|
public class ProcessMXDClass |
|
{ |
|
public ProcessMXDClass() { } |
|
///// <summary> |
|
///// 替换mxd数据源 |
|
///// </summary> |
|
///// <param name="cusPath"></param> |
|
///// <param name="layerNameList"></param> |
|
///// <returns></returns> |
|
//public bool RestFeatureLayerDataSource(ICustomPath cusPath, List<string> layerNameList) |
|
//{ |
|
// IFeatureWorkspace toWorkSpace = null; |
|
// IMapDocument pMapDocument = null; |
|
// try |
|
// { |
|
// if (cusPath == null || layerNameList == null || layerNameList.Count == 0) return false; |
|
// FeatureProcess featureP = new FeatureProcess(); |
|
// toWorkSpace = featureP.GetAcessWorkspace(cusPath.mdbPath); |
|
// if (toWorkSpace == null) |
|
// { |
|
// throw new Exception("打开数据空间失败:" + cusPath.mdbPath); |
|
// } |
|
// pMapDocument = new MapDocumentClass(); |
|
// pMapDocument.Open(cusPath.mxdPath); |
|
// IMap map = pMapDocument.get_Map(0); |
|
// if (map != null) |
|
// { |
|
// foreach (var layerName in layerNameList) |
|
// { |
|
// IFeatureLayer fLayer = FindFeatureLayer(map, layerName); |
|
// if (fLayer == null) |
|
// { |
|
// LogAPI.Debug("未找到层：" + layerName); |
|
// continue; |
|
// } |
|
// fLayer.FeatureClass = toWorkSpace.OpenFeatureClass(layerName); |
|
// } |
|
// pMapDocument.Save(pMapDocument.UsesRelativePaths); |
|
// } |
|
// return true; |
|
// } |
|
// catch (Exception ex) |
|
// { |
|
// throw ex; |
|
// } |
|
// finally |
|
// { |
|
// if (toWorkSpace != null) |
|
// Marshal.ReleaseComObject(toWorkSpace); |
|
// if (pMapDocument != null) |
|
// pMapDocument.Close(); |
|
// } |
|
//} |
|
|
|
public IFeatureLayer FindFeatureLayer(IMap map, string LayerName) |
|
{ |
|
try |
|
{ |
|
|
|
if (map == null || string.IsNullOrEmpty(LayerName)) return null; |
|
ILayer layer = null; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayer(map.get_Layer(i), LayerName); |
|
|
|
if (layer != null) |
|
break; |
|
} |
|
return layer as IFeatureLayer; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return null; |
|
} |
|
} |
|
|
|
public ILayer FindLayer(IMap map, string LayerName) |
|
{ |
|
try |
|
{ |
|
if (map == null || string.IsNullOrEmpty(LayerName)) return null; |
|
ILayer layer = null; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayer(map.get_Layer(i), LayerName); |
|
if (layer != null) |
|
break; |
|
} |
|
return layer; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return null; |
|
} |
|
} |
|
|
|
public int FindLayerIndex(IMap map, string LayerName) |
|
{ |
|
try |
|
{ |
|
if (map == null || string.IsNullOrEmpty(LayerName)) return -1; |
|
int layer = -1; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayerIndex(map.get_Layer(i), LayerName, ref i); |
|
if (layer != null) |
|
break; |
|
} |
|
return layer; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return -1; |
|
} |
|
} |
|
|
|
private int GetLayerIndex(ILayer layer, string layername, ref int layerIndex) |
|
{ |
|
try |
|
{ |
|
if (layer is IGroupLayer) |
|
{ |
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
layerIndex++; |
|
int lay = GetLayerIndex(pComLayer.get_Layer(j), layername, ref layerIndex); |
|
if (lay > 0) |
|
return layerIndex; |
|
} |
|
} |
|
ILayerGeneralProperties generalPro = layer as ILayerGeneralProperties; |
|
if (generalPro != null && generalPro.LayerDescription.ToUpper().Equals(layername.ToUpper())) |
|
return layerIndex; |
|
return -1; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
public IFeatureLayer FindFeatureLayer1(IMap map, string LayerName) |
|
{ |
|
try |
|
{ |
|
|
|
if (map == null || string.IsNullOrEmpty(LayerName)) return null; |
|
ILayer layer = null; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayer1(map.get_Layer(i), LayerName); |
|
|
|
if (layer != null) |
|
break; |
|
} |
|
return layer as IFeatureLayer; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return null; |
|
} |
|
} |
|
|
|
private ILayer GetLayer1(ILayer layer, string layername) |
|
{ |
|
try |
|
{ |
|
if (layer is IGroupLayer) |
|
{ |
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
ILayer lay = GetLayer1(pComLayer.get_Layer(j), layername); |
|
if (lay != null) |
|
return lay; |
|
} |
|
} |
|
if (layer.Name.ToUpper() == layername.ToUpper()) |
|
return layer; |
|
//ILayerGeneralProperties generalPro = layer as ILayerGeneralProperties; |
|
//if (generalPro != null && generalPro.ToUpper().Equals(layername.ToUpper())) |
|
// return layer; |
|
return null; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
private ILayer GetLayer(ILayer layer, string layername) |
|
{ |
|
try |
|
{ |
|
if (layer is IGroupLayer) |
|
{ |
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
ILayer lay = GetLayer(pComLayer.get_Layer(j), layername); |
|
if (lay != null) |
|
return lay; |
|
} |
|
} |
|
ILayerGeneralProperties generalPro = layer as ILayerGeneralProperties; |
|
if (generalPro != null && generalPro.LayerDescription.ToUpper().Equals(layername.ToUpper())) |
|
return layer; |
|
return null; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
public static void SetMxdSpatialReference(string mxdPath, ESRI.ArcGIS.Geometry.ISpatialReference spatialReference) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
|
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map != null) |
|
{ |
|
map.SpatialReference = spatialReference; |
|
pMapDocument.Save(pMapDocument.UsesRelativePaths); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public void SetMXDLayerVisble(string mxdPath, List<string> openList, List<string> closeList) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (openList == null && closeList == null) return; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map != null) |
|
{ |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
SetLayerVisble(map.get_Layer(i), openList, closeList); |
|
} |
|
pMapDocument.Save(pMapDocument.UsesRelativePaths); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public void SetMapLayerVisble(IMap map, string layerName, bool isVisible = true) |
|
{ |
|
try |
|
{ |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
SetLayerVisble(map.get_Layer(i), layerName, isVisible); |
|
} |
|
|
|
|
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
private void SetLayerVisble(ILayer layer, string layerName, bool isVisible = true) |
|
{ |
|
try |
|
{ |
|
if (layer == null) return; |
|
if (string.IsNullOrEmpty(layerName)) return; |
|
ILayerGeneralProperties generalPro = layer as ILayerGeneralProperties; |
|
if (generalPro != null) |
|
{ |
|
string str = generalPro.LayerDescription.Trim(); |
|
if (str == layerName) |
|
{ |
|
layer.Visible = isVisible; |
|
} |
|
else |
|
{ |
|
if (layer is IGroupLayer) |
|
{ |
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
if (pComLayer != null && pComLayer.Count > 0) |
|
{ |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
SetLayerVisble(pComLayer.get_Layer(j), layerName, isVisible); |
|
} |
|
} |
|
layer.Visible = isVisible; |
|
} |
|
else |
|
{ |
|
layer.Visible = false; |
|
} |
|
} |
|
} |
|
|
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
public void SetMapLayerVisbleNew(IMap map, string layerName, bool isVisible = true) |
|
{ |
|
try |
|
{ |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
SetLayerVisbleNew(map.get_Layer(i), layerName, isVisible); |
|
} |
|
|
|
|
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
private void SetLayerVisbleNew(ILayer layer, string layerName, bool isVisible = true) |
|
{ |
|
try |
|
{ |
|
if (layer == null) return; |
|
if (string.IsNullOrEmpty(layerName)) return; |
|
ILayerGeneralProperties generalPro = layer as ILayerGeneralProperties; |
|
if (generalPro != null) |
|
{ |
|
string str = generalPro.LayerDescription.Trim(); |
|
if (str == layerName) |
|
{ |
|
layer.Visible = isVisible; |
|
} |
|
else |
|
{ |
|
if (layer is IGroupLayer) |
|
{ |
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
if (pComLayer != null && pComLayer.Count > 0) |
|
{ |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
SetLayerVisbleNew(pComLayer.get_Layer(j), layerName, isVisible); |
|
} |
|
} |
|
|
|
} |
|
|
|
} |
|
} |
|
|
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
private void SetLayerVisble(ILayer layer, List<string> open, List<string> close) |
|
{ |
|
try |
|
{ |
|
if (layer == null) return; |
|
if (open == null && close == null) return; |
|
ILayerGeneralProperties generalPro = layer as ILayerGeneralProperties; |
|
if (generalPro != null) |
|
{ |
|
string str = generalPro.LayerDescription.Trim(); |
|
if (open != null && open.Contains(str)) |
|
{ |
|
layer.Visible = true; |
|
} |
|
else if (close != null && close.Contains(str)) |
|
{ |
|
layer.Visible = false; |
|
} |
|
else |
|
{ |
|
if (layer is IGroupLayer) |
|
{ |
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
if (pComLayer != null && pComLayer.Count > 0) |
|
{ |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
SetLayerVisble(pComLayer.get_Layer(j), open, close); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
private ILayer GetLayerGroup(ILayer layer, string layername) |
|
{ |
|
try |
|
{ |
|
if (layer is IGroupLayer) |
|
{ |
|
|
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
ILayer lay = GetLayer(pComLayer.get_Layer(j), layername); |
|
if (lay != null) |
|
return lay; |
|
} |
|
ILayerGeneralProperties generalPro = layer as ILayerGeneralProperties; |
|
if (generalPro != null && generalPro.LayerDescription.ToUpper().Equals(layername.ToUpper())) |
|
return layer; |
|
} |
|
|
|
return null; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
public IGroupLayer FindLayerGroup(IMap map, string layerName) |
|
{ |
|
try |
|
{ |
|
if (map == null || string.IsNullOrEmpty(layerName)) return null; |
|
ILayer layer = null; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayerGroup(map.get_Layer(i), layerName); |
|
if (layer != null) |
|
break; |
|
} |
|
return layer == null ? null : layer as IGroupLayer; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return null; |
|
} |
|
} |
|
|
|
public void UpdateMxdLayer(string mxdPath, string layerName, ILayer layerNew) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map == null || map.LayerCount == 0) return; |
|
ILayer layer = null; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayer(map.get_Layer(i), layerName); |
|
if (layer != null) |
|
{ |
|
layer = layerNew; |
|
break; |
|
} |
|
} |
|
pMapDocument.Save(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public ILayer FindLayer(string mxdPath, string layerName) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return null; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map == null || map.LayerCount == 0) return null; |
|
ILayer layer = null; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayer(map.get_Layer(i), layerName); |
|
if (layer != null) |
|
|
|
break; |
|
|
|
} |
|
return layer; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return null; |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public void UpdateLayerName(string mxdPath, string layerName, string layerNewName) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map == null || map.LayerCount == 0) return; |
|
ILayer layer = null; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayer(map.get_Layer(i), layerName); |
|
if (layer != null) |
|
{ |
|
(layer as IFeatureLayer).Name = layerNewName; |
|
break; |
|
} |
|
} |
|
pMapDocument.Save(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public void UpdateLayerVisble(string mxdPath, string layerName, bool isVisble) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map == null || map.LayerCount == 0) return; |
|
ILayer layer = null; |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
layer = GetLayer(map.get_Layer(i), layerName); |
|
if (layer != null) |
|
{ |
|
(layer as IFeatureLayer).Visible = isVisble; |
|
break; |
|
} |
|
} |
|
pMapDocument.Save(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public void UpdateGroupLayerVisble(string mxdPath, string layerName, bool isVisble) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map == null || map.LayerCount == 0) return; |
|
ILayer layer = FindLayerGroup(map, layerName); |
|
(layer as IGroupLayer).Visible = isVisble; |
|
pMapDocument.Save(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public void UpdateGroupLayerName(string mxdPath, string layerName, string layerNewName) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map == null || map.LayerCount == 0) return; |
|
ILayer layer = FindLayerGroup(map, layerName); |
|
(layer as IGroupLayer).Name = layerNewName; |
|
pMapDocument.Save(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public void DelGroupLayer(IMap map, string layerName) |
|
{ |
|
IGroupLayer groupLayer = FindLayerGroup(map, layerName); |
|
if (groupLayer == null) return; |
|
map.DeleteLayer(groupLayer); |
|
} |
|
|
|
public void DelLayer(IMap map, string layerName) |
|
{ |
|
ILayer layer = FindLayer(map, layerName); |
|
if (layer == null) return; |
|
map.DeleteLayer(layer); |
|
} |
|
|
|
public void DelGroupLayer(string mxdPath, string layerName) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map == null || map.LayerCount == 0) return; |
|
ILayer layer = FindLayerGroup(map, layerName); |
|
if (layer != null) map.DeleteLayer(layer); |
|
pMapDocument.Save(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
public void DelLayer(string mxdPath, string layerName) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
IMap map = pMapDocument.get_Map(0); |
|
if (map == null || map.LayerCount == 0) return; |
|
ILayer layer = FindLayerGroup(map, layerName); |
|
if (layer != null) map.DeleteLayer(layer); |
|
pMapDocument.Save(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
/// <summary> |
|
/// 获取map的外界范围 |
|
/// </summary> |
|
/// <param name="map"></param> |
|
/// <returns></returns> |
|
public IEnvelope GetMapEnvelope(string mxdPath) |
|
{ |
|
IMapDocument pMapDocument = null; |
|
try |
|
{ |
|
if (!File.Exists(mxdPath)) return null; |
|
pMapDocument = new MapDocumentClass(); |
|
pMapDocument.Open(mxdPath); |
|
return pMapDocument.ActiveView.Extent; |
|
//IMap map = pMapDocument.get_Map(0); |
|
|
|
//if (map == null || map.LayerCount == 0) return null; |
|
//IEnvelope enve = null; |
|
//for (int i = 0; i < map.LayerCount; i++) |
|
//{ |
|
// GetIEnvelope(map.get_Layer(i), ref enve); |
|
//} |
|
//return enve; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return null; |
|
} |
|
finally |
|
{ |
|
if (pMapDocument != null) |
|
pMapDocument.Close(); |
|
} |
|
} |
|
|
|
private void GetIEnvelope(ILayer layer, ref IEnvelope enve) |
|
{ |
|
try |
|
{ |
|
if (layer == null) return; |
|
|
|
if (layer is IGroupLayer) |
|
{ |
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
if (pComLayer != null && pComLayer.Count > 0) |
|
{ |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
GetIEnvelope(pComLayer.get_Layer(j), ref enve); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if (layer != null && layer.Valid) |
|
{ |
|
IEnvelope env = layer.AreaOfInterest; |
|
if (enve == null) |
|
{ |
|
enve = env; |
|
} |
|
else |
|
{ |
|
if (env != null) |
|
{ |
|
//if (env.XMin < 0 || env.YMin < 0) return; |
|
//if (env.XMax > enve.XMax) |
|
//{ |
|
// enve.XMax = env.XMax; |
|
//} |
|
//if (env.YMax > enve.YMax) |
|
//{ |
|
// enve.YMax = env.YMax; |
|
//} |
|
//if (env.XMin < enve.XMin) |
|
//{ |
|
// enve.XMin = enve.XMin; |
|
//} |
|
//if (env.YMin < enve.YMin) |
|
//{ |
|
// enve.YMin = env.YMin; |
|
//} |
|
enve.Union(env); |
|
} |
|
} |
|
} |
|
} |
|
|
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
public void SetMapLayerVisble(IMap map, List<string> openList, List<string> closeList) |
|
{ |
|
try |
|
{ |
|
if (map == null) return; |
|
if (openList == null && closeList == null) return; |
|
|
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
SetLayerVisble(map.get_Layer(i), openList, closeList); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
finally |
|
{ |
|
} |
|
} |
|
|
|
public static bool RoomToMap(IMap pMap) |
|
{ |
|
try |
|
{ |
|
if (pMap == null) |
|
{ |
|
return false; |
|
} |
|
IActiveView pActiveView = pMap as IActiveView; |
|
double minValue = double.MinValue; |
|
double maxValue = double.MaxValue; |
|
double dlYMax = double.MinValue; |
|
double dlYMin = double.MaxValue; |
|
ILayer pLayer = null; |
|
//IFeatureLayer layer2 = null; |
|
for (int i = 0; i < pMap.LayerCount; i++) |
|
{ |
|
pLayer = pMap.get_Layer(i); |
|
//layer2 = pLayer as IFeatureLayer; |
|
//if ((layer2 != null) && (layer2.FeatureClass != null)) |
|
//{ |
|
// string str = TrimUserName((layer2.FeatureClass as IDataset).BrowseName); |
|
// if (((str == DBConst.TB_LSD) || (str == DBConst.TB_LSX)) || (str == DBConst.TB_LSM)) |
|
// { |
|
// continue; |
|
// } |
|
//} |
|
if (pLayer is ICompositeLayer) |
|
{ |
|
GetCompositeLayerSideCoordinate(pLayer as ICompositeLayer, ref minValue, ref maxValue, ref dlYMax, ref dlYMin); |
|
|
|
} |
|
else |
|
{ |
|
GetLayerSideCoordinate(pLayer, ref minValue, ref maxValue, ref dlYMax, ref dlYMin); |
|
} |
|
} |
|
if ((((minValue == double.MinValue) && (maxValue == double.MaxValue)) && (dlYMax == double.MinValue)) && (dlYMin == double.MaxValue)) |
|
{ |
|
pActiveView.Extent = pActiveView.FullExtent; |
|
PartialRefresh(pActiveView); |
|
} |
|
else |
|
{ |
|
IEnvelope pGeometry = new EnvelopeClass();//GetEnvByCoor(minValue, maxValue, dlYMax, dlYMin); |
|
pGeometry.XMax = minValue; |
|
pGeometry.XMin = maxValue; |
|
pGeometry.YMax = dlYMax; |
|
pGeometry.YMin = dlYMin; |
|
|
|
LocateGeometry(pActiveView, pGeometry, 0.2); |
|
} |
|
|
|
return true; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return false; |
|
} |
|
finally |
|
{ |
|
|
|
} |
|
} |
|
|
|
public static bool LocateGeometry(IActiveView pActiveView, IGeometry pGeometry, double dblRatio) |
|
{ |
|
try |
|
{ |
|
if ((pGeometry == null) || (pActiveView == null)) |
|
{ |
|
return false; |
|
} |
|
if (pGeometry.IsEmpty) |
|
{ |
|
return false; |
|
} |
|
if ((pGeometry is IPoint) || (pGeometry is IMultipoint)) |
|
{ |
|
ITopologicalOperator @operator = pGeometry as ITopologicalOperator; |
|
@operator.Simplify(); |
|
pGeometry = @operator.Buffer(100.0); |
|
} |
|
IEnvelope envelope = pGeometry.Envelope; |
|
IPoint p = new PointClass(); |
|
if (envelope != null) |
|
{ |
|
p.X = (envelope.XMin + envelope.XMax) / 2.0; |
|
p.Y = (envelope.YMin + envelope.YMax) / 2.0; |
|
} |
|
double num = pActiveView.Extent.Width / pActiveView.Extent.Height; |
|
double num2 = envelope.Width / envelope.Height; |
|
if (num > num2) |
|
{ |
|
envelope.Width = envelope.Height * num; |
|
} |
|
else |
|
{ |
|
envelope.Height = envelope.Width / num; |
|
} |
|
envelope.Expand(1.0 + dblRatio, 1.0 + dblRatio, true); |
|
envelope.CenterAt(p); |
|
if (envelope.SpatialReference != pActiveView.FocusMap.SpatialReference) |
|
{ |
|
envelope.Project(pActiveView.FocusMap.SpatialReference); |
|
} |
|
pActiveView.Extent = envelope; |
|
PartialRefresh(pActiveView); |
|
pActiveView.ScreenDisplay.UpdateWindow(); |
|
return true; |
|
} |
|
catch (Exception) |
|
{ |
|
return false; |
|
} |
|
} |
|
public static bool PartialRefresh(IActiveView pActiveView) |
|
{ |
|
if (pActiveView == null) |
|
{ |
|
return false; |
|
} |
|
PartialRefresh(pActiveView, esriViewDrawPhase.esriViewForeground | esriViewDrawPhase.esriViewGraphicSelection | esriViewDrawPhase.esriViewGraphics | esriViewDrawPhase.esriViewGeoSelection | esriViewDrawPhase.esriViewGeography | esriViewDrawPhase.esriViewBackground); |
|
return true; |
|
} |
|
|
|
public static bool PartialRefresh(IActiveView pActiveView, esriViewDrawPhase enumViewDrawPhase) |
|
{ |
|
if (pActiveView == null) |
|
{ |
|
return false; |
|
} |
|
pActiveView.PartialRefresh(enumViewDrawPhase, null, pActiveView.Extent); |
|
return true; |
|
} |
|
|
|
private static bool GetCompositeLayerSideCoordinate(ICompositeLayer pCompositeLayer, ref double dlXMax, ref double dlXMin, ref double dlYMax, ref double dlYMin) |
|
{ |
|
if (pCompositeLayer == null) |
|
{ |
|
return false; |
|
} |
|
for (int i = 0; i < pCompositeLayer.Count; i++) |
|
{ |
|
ILayer pLayer = pCompositeLayer.get_Layer(i); |
|
if (pLayer is ICompositeLayer) |
|
{ |
|
if (!GetCompositeLayerSideCoordinate(pLayer as ICompositeLayer, ref dlXMax, ref dlXMin, ref dlYMax, ref dlYMin)) |
|
{ |
|
return false; |
|
} |
|
} |
|
else if (!GetLayerSideCoordinate(pLayer, ref dlXMax, ref dlXMin, ref dlYMax, ref dlYMin)) |
|
{ |
|
return false; |
|
} |
|
} |
|
return true; |
|
} |
|
|
|
private static bool GetLayerSideCoordinate(ILayer pLayer, ref double dlXMax, ref double dlXMin, ref double dlYMax, ref double dlYMin) |
|
{ |
|
if (pLayer == null || !pLayer.Valid) |
|
{ |
|
return false; |
|
} |
|
if (pLayer is ITable) |
|
{ |
|
try |
|
{ |
|
if ((pLayer as ITable).RowCount(null) == 0) |
|
{ |
|
return true; |
|
} |
|
} |
|
catch (Exception) |
|
{ |
|
} |
|
} |
|
IEnvelope areaOfInterest = pLayer.AreaOfInterest; |
|
if (areaOfInterest != null) |
|
{ |
|
dlXMax = Math.Max(dlXMax, areaOfInterest.XMax); |
|
dlXMin = Math.Min(dlXMin, areaOfInterest.XMin); |
|
dlYMax = Math.Max(dlYMax, areaOfInterest.YMax); |
|
dlYMin = Math.Min(dlYMin, areaOfInterest.YMin); |
|
} |
|
return true; |
|
} |
|
|
|
|
|
|
|
|
|
} |
|
}
|
|
|