// 递归获取 GroupLayer 中的图层
private List <IFeatureLayer> GetFeatureLayerFromGroupLayer(IGroupLayer groupLayer)
{
List <IFeatureLayer> outLayerList = new List <IFeatureLayer>();
var compositeLayer = (ICompositeLayer)groupLayer;
for (int j = 0; j < compositeLayer.Count; j++)
{
var subLayer = compositeLayer.Layer[j];
if (subLayer is IFeatureLayer)
{
var featureLayer = (IFeatureLayer)subLayer;
var featureClass = featureLayer.FeatureClass;
if (featureClass == null)
{
continue;
}
if (featureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
outLayerList.Add(featureLayer);
}
}
else if (subLayer is IGroupLayer)
{
GetFeatureLayerFromGroupLayer((IGroupLayer)subLayer).ForEach(p => outLayerList.Add(p));
}
}
return(outLayerList);
}
private void method_5(IGroupLayer igroupLayer_0, ILayer ilayer_0, bool bool_1)
{
if (bool_1)
{
bool flag = true;
if (ilayer_0 is IGeoFeatureLayer)
{
IFeatureClass featureClass = (ilayer_0 as IGeoFeatureLayer).FeatureClass;
flag = featureClass.FeatureCount(null) > 0;
}
if (flag)
{
if (this.ienvelope_0 != null)
{
IEnvelope areaOfInterest = ilayer_0.AreaOfInterest;
if ((areaOfInterest.SpatialReference is IUnknownCoordinateSystem ||
this.ienvelope_0.SpatialReference is IUnknownCoordinateSystem ||
this.ienvelope_0.SpatialReference == null
? false
: areaOfInterest.SpatialReference != null))
{
areaOfInterest.Project(this.ienvelope_0.SpatialReference);
this.ienvelope_0.Union(areaOfInterest);
}
}
else
{
this.ienvelope_0 = ilayer_0.AreaOfInterest;
}
}
}
igroupLayer_0.Add(ilayer_0);
}
/// <summary>
/// 图层查找 确定图层的存在性 包括组合图层
/// </summary>
/// <param name="groupName"></param>
/// <param name="layerName"></param>
/// <param name="gLayer"></param>
/// <returns></returns>
public static ILayer QueryLayerInMap(AxMapControl mapControl, string layerName, ref IGroupLayer gLayer, out int layerIndex, out int groupIndex)
{
layerIndex = -1;
groupIndex = -1;
ILayer queryLayer = null;
for (int i = 0; i < mapControl.Map.LayerCount; i++)
{
ILayer tempLayer = mapControl.Map.get_Layer(i);
if (tempLayer is IGroupLayer)
{
IGroupLayer tempGlayer = tempLayer as IGroupLayer;
ILayer querylayer2 = QueryLayerInGroupLayer(layerName, tempGlayer, ref layerIndex);
if (querylayer2 != null)
{
queryLayer = querylayer2;
gLayer = tempGlayer;
groupIndex = i;
break;
}
}
if (tempLayer.Name == layerName)
{
queryLayer = tempLayer;
layerIndex = i;
break;
}
}
return(queryLayer);
}
/// <summary>
/// 查找图层 包括组合图层
/// </summary>
/// <param name="groupName"></param>
/// <param name="layerName"></param>
/// <param name="gLayer"></param>
/// <returns></returns>
public static bool QueryLayerInMap(IMapControl3 mapControl, ILayer searchLayer, ref IGroupLayer gLayer, out int layerIndex, out int groupIndex)
{
layerIndex = -1;
groupIndex = -1;
ILayer queryLayer = null;
for (int i = 0; i < mapControl.Map.LayerCount; i++)
{
ILayer tempLayer = mapControl.Map.get_Layer(i);
if (tempLayer is IGroupLayer)
{
IGroupLayer tempGlayer = tempLayer as IGroupLayer;
if (QueryLayerInGroupLayer(searchLayer, tempGlayer, ref layerIndex))
{
gLayer = tempGlayer;
groupIndex = i;
return(true);
}
}
if (tempLayer == searchLayer)
{
queryLayer = tempLayer;
layerIndex = i;
return(true);
}
}
return(false);
}
private static IFeatureLayer IsFeatureLayerInGroupLayer(string sSource, IGroupLayer pGrpLyr)
{
if (pGrpLyr == null)
{
return(null);
}
ESRI.ArcGIS.ArcMapUI.IMxDocument pMXDoc = ArcMap.Document;
IMap pMap = pMXDoc.FocusMap;
ICompositeLayer compositeLayer = pGrpLyr as ICompositeLayer;
if (compositeLayer != null & compositeLayer.Count > 0)
{
for (int i = 0; i <= compositeLayer.Count - 1; i++)
{
if (compositeLayer.Layer[i] is IFeatureLayer)
{
ESRI.ArcGIS.Geodatabase.IDataset pLayer = (ESRI.ArcGIS.Geodatabase.IDataset)compositeLayer.Layer[i];
string pLayerPath = Path.Combine(pLayer.Workspace.PathName, pLayer.BrowseName + ".shp");
if (string.Compare(pLayerPath, sSource, true) == 0)
{
return((IFeatureLayer)pLayer);
}
}
}
}
return(null);
}
public override void OnClick()
{
int playerCount = myHook.MapControl.Map.LayerCount;//获得MapControl上图层的数量
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
ILayer mLayer = myHook.MapControl.CustomProperty as ILayer;
if (mLayer is IGroupLayer)
{
IGroupLayer pGLayer = mLayer as IGroupLayer;
if (pGLayer.Expanded == false)
{
pGLayer.Expanded = true;
}
ExpandGroupLayer(pGLayer);
}
else if (mLayer is IFeatureLayer)
{
pFeatureLayer = mLayer as IFeatureLayer;
ExpandLayer(pFeatureLayer);
}
if (this.WriteLog)
{
Plugin.LogTable.Writelog(Message); //xisheng 2011.07.08 增加日志
}
myHook.TOCControl.Update();
}
private IGroupLayer GetGroupLayer()
{
IGroupLayer result = null;
IMap map = ArcUtils.Map;
if (map != null)
{
// ReSharper disable UseIndexedProperty
var layers = map.get_Layers();
bool leave = false;
ILayer layer;
while (((layer = layers.Next()) != null) && (!leave))
{
if (layer.Name == Name)
{
if (layer is GroupLayer)
{
result = layer as IGroupLayer;
leave = true;
}
else
{
map.DeleteLayer(layer);
}
}
}
// ReSharper restore UseIndexedProperty
}
return(result);
}
private void ParseGroupLayer(XmlDocument axl, IGroupLayer gLayer)
{
if (gLayer == null)
{
return;
}
foreach (ILayer layer in gLayer.ChildLayer)
{
if (layer is IGroupLayer)
{
ParseGroupLayer(axl, layer as IGroupLayer);
}
else
{
XmlNode layerNode = GetLayernode(axl, layer as IFeatureLayer);
if (layerNode == null)
{
continue;
}
SetLayernameAndScales(layerNode, layer as IFeatureLayer);
SetRenderers(layerNode, layer as IFeatureLayer);
if (_doc != null && _doc.Application is IMapApplication)
{
((IMapApplication)_doc.Application).RefreshTOCElement(layer);
}
}
}
}
/// <summary>
/// 处理空间统计
/// </summary>
/// <param name="mapControl"></param>
/// <param name="pGeometry"></param>
/// <param name="layerName"></param>
public void DealFeatureQuery(AxMapControl mapControl, IGeometry pGeometry, string queryStr, string layerName)
{
IGroupLayer gLayer = null;
if (string.IsNullOrEmpty(layerName))
{
return;
}
int gIndex;
int layerIndex;
IFeatureLayer pFeatureLayer = LayerUtil.QueryLayerInMap(mapControl, layerName, ref gLayer, out layerIndex, out gIndex) as IFeatureLayer;
if (pFeatureLayer == null)
{
return;
}
IQueryFilter queryFilter = null;
IFeatureCursor pFeatureCursor = null;
if (string.IsNullOrEmpty(queryStr))
{
pFeatureCursor = FeatureDealUtil.QueryFeatureInLayer(pFeatureLayer, pGeometry, ref queryFilter);
}
else
{
pFeatureCursor = FeatureDealUtil.QueryFeatureInLayer(pFeatureLayer, queryStr, ref queryFilter);
}
IList <IFeature> features = FlashFeatureShape(mapControl, pFeatureLayer, pFeatureCursor);
ShowFeatureDetail(pFeatureLayer, features, queryFilter);
}
//使图层组内所有图层可见
private bool VisibleGroupLayer(IGroupLayer pGroupLayer)
{
bool changed = false;
ICompositeLayer pComLayer = pGroupLayer as ICompositeLayer;
if (pComLayer != null)
{
for (int i = 0; i < pComLayer.Count; i++)
{
ILayer player = pComLayer.get_Layer(i);
if (!player.Visible)
{
player.Visible = true;
changed = true;
}
if (player is IGroupLayer)
{
bool bRes = VisibleGroupLayer(player as IGroupLayer);
if (bRes)
{
changed = true;
}
}
}
}
return(changed);
}
private bool AddGroupLayer(IGroupLayer pGroupLayer)
{
bool flag;
ICompositeLayer compLayer = pGroupLayer as ICompositeLayer;
for (int i = 0; i < compLayer.Count; i++)
{
ILayer layer = compLayer.Layer[i] as ILayer;
if (layer is IGroupLayer)
{
this.AddGroupLayer(layer as IGroupLayer);
}
else if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
if (featureLayer != null)
{
if (featureLayer is IFDOGraphicsLayer)
{
continue;
}
if (featureLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
this.AddLayer(layer, 0);
flag = true;
break;
}
}
}
}
return(true);
}
/// <summary>
/// 移动图层到组合图层的对应位置 单纯移除
/// </summary>
/// <param name="removedLayer"></param>
/// <param name="toGroupLayer"></param>
/// <param name="toIndex"></param>
private static void MoveLayerToGroupIndex(ILayer removedLayer, IGroupLayer toGroupLayer, int toIndex)
{
ICompositeLayer pComposite = toGroupLayer as ICompositeLayer;
IList <ILayer> tempLayers = new List <ILayer>();
//移除toIndex后面的所有图层
for (int i = toIndex; i < pComposite.Count; i++)
{
ILayer tempLayer = pComposite.get_Layer(i);
tempLayers.Add(tempLayer);
}
foreach (var layer in tempLayers)
{
toGroupLayer.Delete(layer);
}
//添加待移除图层
toGroupLayer.Add(removedLayer);
//添加图层
foreach (var layer in tempLayers)
{
if (layer != removedLayer)
{
toGroupLayer.Add(layer);
}
}
}
//通过intersect关系进行裁切
public void ClipByExtent(int groupNm, int extNum)
{
IGeometry extent = GetClipExtent(extNum);
string findName = "grp" + groupNm.ToString() + "ext0";
IGroupLayer grpLy = avlbLayers.Find(item => item.Name == findName);
ICompositeLayer comLy = grpLy as ICompositeLayer;
IGroupLayer newGroupLayer = new GroupLayerClass();
newGroupLayer.Name = "grp" + groupNm.ToString() + "ext" + extNum.ToString();
for (int i = 0; i < comLy.Count; i++)
{
IFeatureLayer feaLy = comLy.get_Layer(i) as IFeatureLayer;
IFeatureClass clipFC = feaLy.FeatureClass;
IFields flds = clipFC.Fields;
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = extent;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
IFeatureCursor cursor = clipFC.Search(spatialFilter, false);
IWorkspaceFactory workspaceFactory = new InMemoryWorkspaceFactoryClass();
IWorkspaceName workspaceName = workspaceFactory.Create(null, "MyWorkspace", null, 0);
IName name = (IName)workspaceName;
IWorkspace workspace = (IWorkspace)name.Open();
IFeatureWorkspace inmemFeaWksp = workspace as IFeatureWorkspace;
if (clipFC.ShapeType == esriGeometryType.esriGeometryPoint)
{
IFeatureClass inmemPTFC = CreateWithoutDescription("inmemPTFC_" + groupNumber.ToString(), null, inmemFeaWksp, clipFC.ShapeType, flds);
InsertFeaturesBoun(inmemPTFC, cursor, extent);
IFeatureLayer inmemPTFCLayer = new FeatureLayerClass();
inmemPTFCLayer.FeatureClass = inmemPTFC;
newGroupLayer.Add(inmemPTFCLayer);
}
else if (clipFC.ShapeType == esriGeometryType.esriGeometryPolyline)
{
IFeatureClass inmemLNFC = CreateWithoutDescription("inmemLNFC" + groupNumber.ToString(), null, inmemFeaWksp, clipFC.ShapeType, flds);
InsertFeaturesBoun(inmemLNFC, cursor, extent);
IFeatureLayer inmemLNFCLayer = new FeatureLayerClass();
inmemLNFCLayer.FeatureClass = inmemLNFC;
newGroupLayer.Add(inmemLNFCLayer);
}
else if (clipFC.ShapeType == esriGeometryType.esriGeometryPolygon)
{
IFeatureClass inmemPLGFC = CreateWithoutDescription("inmemPLGFC" + groupNumber.ToString(), null, inmemFeaWksp, clipFC.ShapeType, flds);
InsertFeaturesBoun(inmemPLGFC, cursor, extent);
IFeatureLayer inmemPLGFCLayer = new FeatureLayerClass();
inmemPLGFCLayer.FeatureClass = inmemPLGFC;
newGroupLayer.Add(inmemPLGFCLayer);
}
}
avlbLayers.Add(newGroupLayer);
}
private IGroupLayer AddErrorSurfacesGroupLayer(DEMSurvey dem)
{
IGroupLayer pSurveyGrpLyr = AddSurveyGroupLayer(dem);
IGroupLayer pErrGrpLyr = ArcMapUtilities.GetGroupLayer(ErrorSurfacesGroupLayer, pSurveyGrpLyr);
return(pErrGrpLyr);
}
/// <summary>
/// 将一个地图中的所有图层加入Hashtable
/// </summary>
/// <param name="obj"></param>
/// <param name="list"></param>
public static void GetAllFeatureLayer(object obj, Hashtable ht)
{
if (obj is IMap)
{
IMap pMap = obj as IMap;
for (int i = 0; i < pMap.LayerCount; i++)
{
GetAllFeatureLayer(pMap.get_Layer(i), ht);
}
}
else if (obj is IGroupLayer)
{
IGroupLayer pGroupLayer = obj as IGroupLayer;
if (pGroupLayer.Visible == true)
{
ICompositeLayer comLayer = obj as ICompositeLayer;
for (int i = 0; i < comLayer.Count; i++)
{
GetAllFeatureLayer(comLayer.get_Layer(i), ht);
}
}
}
else if ((obj is IFeatureLayer) && !(obj is IAnnotationLayer) && !(obj is ICadLayer))
{
if (ht != null)
{
IFeatureLayer pFeaLay = obj as IFeatureLayer;
if (ht[pFeaLay.FeatureClass.FeatureClassID] == null && pFeaLay.Visible == true) //--------By 袁怀月--------------
{
ht.Add(pFeaLay.FeatureClass.FeatureClassID, pFeaLay);
}
}
}
}
public void AddMask(GCDCore.Project.Masks.AttributeFieldMask mask)
{
IGroupLayer pProjLyr = AddProjectGroupLayer();
IGroupLayer pGrpLayer = ArcMapUtilities.GetGroupLayer(MasksGroupLayer, pProjLyr);
short dTransparency = GCDCore.Properties.Settings.Default.TransparencyAssociatedLayers ? GCDCore.Properties.Settings.Default.AutoTransparencyValue : (short)-1;
IFeatureRenderer pRenderer = null;
string queryFilter = string.Empty;
string labelField = string.Empty;
if (mask is GCDCore.Project.Masks.RegularMask)
{
GCDCore.Project.Masks.RegularMask rMask = mask as GCDCore.Project.Masks.RegularMask;
pRenderer = VectorSymbolization.GetRegularMaskRenderer(rMask) as IFeatureRenderer;
// Create a definition query if some features are not included
if (rMask._Items.Any(x => !x.Include))
{
queryFilter = string.Format("\"{0}\" IN ('{1}')", mask._Field, string.Join("','", rMask._Items.Where(x => x.Include).Select(y => y.FieldValue)));
}
}
else if (mask is GCDCore.Project.Masks.DirectionalMask)
{
GCDCore.Project.Masks.DirectionalMask dirMask = mask as GCDCore.Project.Masks.DirectionalMask;
// Directional mask. Black outline with labels
pRenderer = VectorSymbolization.GetDirectionalMaskRenderer(dirMask) as IFeatureRenderer;
labelField = string.IsNullOrEmpty(dirMask.LabelField) ? dirMask._Field : dirMask.LabelField;
}
VectorSymbolization.AddToMapVector(mask.Vector.GISFileInfo, mask.Name, pGrpLayer, mask._Field, pRenderer, queryFilter, labelField, dTransparency);
}
private IGroupLayer AddAnalysesGroupLayer()
{
IGroupLayer pProjLyr = AddProjectGroupLayer();
IGroupLayer pAnalGrpLyr = ArcMapUtilities.GetGroupLayer(AnalysesGroupLayer, pProjLyr);
return(pAnalGrpLyr);
}
public void AddAssociatedSurface(AssocSurface assocRow)
{
IGroupLayer pAssocGrpLyr = AddAssociatedSurfaceGroupLayer(assocRow.DEM);
short dTransparency = GCDCore.Properties.Settings.Default.TransparencyAssociatedLayers ? GCDCore.Properties.Settings.Default.AutoTransparencyValue : (short)-1;
IRasterRenderer rasterRenderer = null;
switch (assocRow.AssocSurfaceType)
{
case AssocSurface.AssociatedSurfaceTypes.InterpolationError:
if (!GCDCore.Properties.Settings.Default.ApplyComparativeSymbology)
{
rasterRenderer = RasterSymbolization.CreateClassifyRenderer(assocRow.Raster, 11, "Slope");
}
break;
case AssocSurface.AssociatedSurfaceTypes.PointQuality3D:
if (!GCDCore.Properties.Settings.Default.ApplyComparativeSymbology)
{
rasterRenderer = RasterSymbolization.CreateClassifyRenderer(assocRow.Raster, 11, "Precipitation", true);
}
break;
case AssocSurface.AssociatedSurfaceTypes.PointDensity:
assocRow.Raster.ComputeStatistics();
decimal rasterMax = assocRow.Raster.GetStatistics()["max"];
if (rasterMax <= 2 & rasterMax > 0.25m)
{
rasterRenderer = RasterSymbolization.CreateClassifyRenderer(assocRow.Raster, 11, "Green to Blue", 1.1, true);
}
else
{
rasterRenderer = RasterSymbolization.CreateClassifyRenderer(assocRow.Raster, 11, "Green to Blue", true);
}
break;
case AssocSurface.AssociatedSurfaceTypes.GrainSizeStatic:
rasterRenderer = RasterSymbolization.CreateGrainSizeStatisticColorRamp(assocRow.Raster, ProjectManager.Project.Units.VertUnit);
break;
case AssocSurface.AssociatedSurfaceTypes.Roughness:
rasterRenderer = RasterSymbolization.CreateRoughnessColorRamp(assocRow.Raster);
break;
case AssocSurface.AssociatedSurfaceTypes.SlopeDegree:
rasterRenderer = RasterSymbolization.CreateSlopeDegreesColorRamp(assocRow.Raster);
break;
case AssocSurface.AssociatedSurfaceTypes.SlopePercent:
rasterRenderer = RasterSymbolization.CreateSlopePrecentRiseColorRamp(assocRow.Raster);
break;
}
AddRasterLayer(assocRow.Raster, rasterRenderer, assocRow.Name, pAssocGrpLyr, assocRow.LayerHeader, dTransparency);
}
// =========================================================================
// Functions (private)
// =========================================================================
private void CreateLayers()
{
if (GroupLayer == null)
{
IMap map = ArcUtils.Map;
if (map != null)
{
_groupLayer = new GroupLayerClass();
if (_groupLayer != null)
{
_groupLayer.Name = Name;
}
CreateFeatureLayers();
var layer = _groupLayer as ILayer;
map.AddLayer(layer);
}
}
else
{
CreateFeatureLayers();
}
}
private void method_2(IGroupLayer igroupLayer_1, ILayer ilayer_0, int int_0)
{
ICompositeLayer layer = igroupLayer_1 as ICompositeLayer;
if ((layer.Count - 1) == int_0)
{
igroupLayer_1.Delete(ilayer_0);
igroupLayer_1.Add(ilayer_0);
}
else
{
int num;
IArray array = new ArrayClass();
for (num = 0; num < layer.Count; num++)
{
array.Add(layer.get_Layer(num));
}
igroupLayer_1.Clear();
for (num = 0; num < array.Count; num++)
{
if (layer.Count == int_0)
{
igroupLayer_1.Add(ilayer_0);
}
ILayer layer2 = array.get_Element(num) as ILayer;
if (layer2 != ilayer_0)
{
igroupLayer_1.Add(layer2);
}
}
}
}
public override void OnClick()
{
int playerCount = myHook.MapControl.Map.LayerCount;//获得MapControl上图层的数量
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
for (int i = 0; i < playerCount; i++)
{
ILayer player = myHook.MapControl.Map.get_Layer(i);
if (player is IGroupLayer)
{
//如果图层是GroupLayer，那么将它的Expanded设置成FALSE
IGroupLayer pGroupLayer = player as IGroupLayer;
CollapseGroupLayer(pGroupLayer);
pGroupLayer.Expanded = false;
}
else if (player is IFeatureLayer)
{
//如果不是GroupLayer，利用pLegendGroup.Visible来折叠图层
pFeatureLayer = player as IFeatureLayer;
CollapseLayer(pFeatureLayer);
}
}
Plugin.LogTable.Writelog(base._Tooltip);//xisheng 2011.07.08 增加日志
myHook.TOCControl.Update();
}
private IGroupLayer AddReferenceErrorSurfacesGroupLayer(Surface surf)
{
IGroupLayer pSurveyGrpLyr = AddReferenceSurfaceGroupLayer(surf);
IGroupLayer pErrGrpLyr = ArcMapUtilities.GetGroupLayer(ErrorSurfacesGroupLayer, pSurveyGrpLyr);
return(pErrGrpLyr);
}
public override void OnClick()
{
int playerCount = myHook.MapControl.Map.LayerCount;//获得MapControl上图层的数量
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
for (int i = 0; i < playerCount; i++)
{
ILayer player = myHook.MapControl.Map.get_Layer(i);
if (player is IGroupLayer)
{
//如果时GroupLayer，则利用它的Expended属性来扩展图层
IGroupLayer pGroupLayer = player as IGroupLayer;
ExpandGroupLayer(pGroupLayer);
pGroupLayer.Expanded = true;
}
else if (player is IFeatureLayer)
{
//如果是普通的图层，利用pLegendGroup.Visible来扩展图层
pFeatureLayer = player as IFeatureLayer;
ExpandLayer(pFeatureLayer);
}
}
if (this.WriteLog)
{
Plugin.LogTable.Writelog(Message);//xisheng 2011.07.08 增加日志
}
myHook.TOCControl.Update();
}
private IGroupLayer AddSurveyGroupLayer(DEMSurvey dem)
{
IGroupLayer pInputsGrpLyr = AddInputsGroupLayer();
IGroupLayer pSurveysGrpLyr = ArcMapUtilities.GetGroupLayer(SurveysGroupLayer, pInputsGrpLyr);
return(ArcMapUtilities.GetGroupLayer(dem.Name, pSurveysGrpLyr));
}
public static IGroupLayer GetGroupLayer(string sName, IGroupLayer pParentGroupLayer, bool bCreateIfNeeded = true)
{
if (string.IsNullOrEmpty(sName))
{
// This route might be needed if the GCD calls this function without an open project.
return(null);
}
// Try and find the group layer already in the hierarchy
ICompositeLayer pCompositeLayer = (ICompositeLayer)pParentGroupLayer;
for (int i = 0; i <= pCompositeLayer.Count - 1; i++)
{
if (string.Compare(pCompositeLayer.Layer[i].Name, sName, true) == 0)
{
return((IGroupLayer)pCompositeLayer.Layer[i]);
}
}
IGroupLayer pResultLayer = new GroupLayer();
pResultLayer.Name = sName;
((IMapLayers)ArcMap.Document.FocusMap).InsertLayerInGroup(pParentGroupLayer, pResultLayer, true, 0);
return(pResultLayer);
}
private IGroupLayer AddReferenceSurfaceGroupLayer(Surface surf)
{
IGroupLayer pInputsGrpLyr = AddInputsGroupLayer();
IGroupLayer pRefSurfGrpLyr = ArcMapUtilities.GetGroupLayer(RefSurfGroupLayer, pInputsGrpLyr);
return(ArcMapUtilities.GetGroupLayer(surf.Name, pRefSurfGrpLyr));
}
/// <summary>
/// 在组合图层内部进行移动
/// </summary>
/// <param name="removedLayer"></param>
/// <param name="groupLayer"></param>
/// <param name="fromIndexObj"></param>
/// <param name="toIndexObj"></param>
private static void MoveInSameGroupLayer(ILayer removedLayer, IGroupLayer groupLayer, object fromIndexObj, object toIndexObj)
{
if (toIndexObj == null)
{
groupLayer.Delete(removedLayer);
AddMyLayer(groupLayer, removedLayer);
return;
}
int fromIndex = (int)fromIndexObj;
int toIndex = (int)toIndexObj;
if (fromIndex == toIndex)
{
return;
}
if (fromIndex < toIndex)
{
groupLayer.Delete(removedLayer);
// toIndex--;
}
//else
//{
// toIndex--;
// groupLayer.Delete(removedLayer);
//}
MoveLayerToGroupIndex(removedLayer, groupLayer, toIndex);
}
private void AddChildrenToMap(TreeNode e)
{
e.Nodes.OfType <TreeNode>().ToList().ForEach(x => AddChildrenToMap(x));
GISDataset ds = null;
if (e.Tag is GISDataset)
{
ds = e.Tag as GISDataset;
}
else if (e.Tag is ProjectView)
{
((ProjectView)e.Tag).Layers.ForEach(x => AddChildrenToMap(x.LayerNode));
}
if (ds is GISDataset)
{
GISDataset layer = (GISDataset)e.Tag;
IGroupLayer parentGrpLyr = BuildArcMapGroupLayers(e);
FileInfo symbology = GetSymbology(layer);
string def_query = ds is Vector ? ((Vector)ds).DefinitionQuery : string.Empty;
ArcMapUtilities.AddToMap(layer, layer.Name, parentGrpLyr, GetPrecedingLayers(e), symbology, transparency: layer.Transparency, definition_query: def_query);
Cursor.Current = Cursors.Default;
}
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
groupNumber = listBox1.SelectedIndex + 1;
int extentStatus = findExtentStatus(groupNumber);
comboBox1.SelectedIndex = extentStatus;
//检查grouplayer列表中是否已经存在当前请求的图层
bool exist = CheckAvailability(groupNumber, extentStatus);
string findName = "grp" + groupNumber.ToString() + "ext" + extentStatus.ToString();
//如果已经存在，直接加载
if (exist == true)
{
Clear();
IGroupLayer viewGrpLys = avlbLayers.Find(item => item.Name == findName);
mapControl.AddLayer(viewGrpLys);
}
//如果不存在，先进行裁切并添加到grouplayer列表中，再加载
else
{
Clear();
ClipByExtent(groupNumber, extentStatus);
IGroupLayer newGrpLys = avlbLayers.Find(item => item.Name == findName);
mapControl.AddLayer(newGrpLys);
}
}
private void AddLayer(IGroupLayer igroupLayer_0, ILayer ilayer_0, ref IEnvelope ienvelope_0)
{
bool flag = true;
if (ilayer_0 is IGeoFeatureLayer)
{
IFeatureClass featureClass = (ilayer_0 as IGeoFeatureLayer).FeatureClass;
flag = (featureClass.FeatureCount(null) > 0);
}
if (flag)
{
if (ienvelope_0 == null)
{
ienvelope_0 = ilayer_0.AreaOfInterest;
}
else
{
IEnvelope areaOfInterest = ilayer_0.AreaOfInterest;
if (!(areaOfInterest.SpatialReference is IUnknownCoordinateSystem) && !(ienvelope_0.SpatialReference is IUnknownCoordinateSystem) && ienvelope_0.SpatialReference != null && areaOfInterest.SpatialReference != null)
{
areaOfInterest.Project(ienvelope_0.SpatialReference);
ienvelope_0.Union(areaOfInterest);
}
}
}
igroupLayer_0.Add(ilayer_0);
}
public IGroupLayer FindParentGroupLayer(IGroupLayer groupLayer, ILayer layer)
{
if (!(groupLayer is ICompositeLayer))
{
return groupLayer;
}
ICompositeLayer comLayer = groupLayer as ICompositeLayer;
ILayer tmpLayer;
for (int i = 0; i <= comLayer.Count - 1; i++)
{
tmpLayer = comLayer.get_Layer(i);
if (tmpLayer == layer)
return groupLayer;
else if (tmpLayer is IGroupLayer)
return FindParentGroupLayer(tmpLayer as IGroupLayer, layer);
}
return null;
}
private void setgisxml(ref System.Data.DataTable dt,IGroupLayer pGroupLayer)
{
ICompositeLayer comLayer = pGroupLayer as ICompositeLayer;
System.Data.DataRow dr;
for (int i = 0; i < comLayer.Count; i++)
{
ILayer player = comLayer.get_Layer(i);
if (player is IGroupLayer)
{
dr = dt.NewRow();
dr[0] = "layer";
dr[1] = player.Name;
dr[2] = player.Visible.ToString();
dt.Rows.Add(dr);
setgisxml(ref dt, player as IGroupLayer);
}
else
{
dr = dt.NewRow();
dr[0] = "layer";
dr[1] = player.Name;
dr[2] = player.Visible.ToString();
dt.Rows.Add(dr);
}
}
}
/// <summary>
/// AddNATraversalResultLayersToGroup will take the traversal results from an INAResult and add them to the map as a group layer
/// </summary>
private void AddNATraversalResultLayersToGroup(IGroupLayer groupLayer, INAResult result)
{
var naTraversalResultQuery = result as INATraversalResultQuery2;
groupLayer.Add(GetTraversalResultLayer(esriNetworkElementType.esriNETJunction, naTraversalResultQuery));
groupLayer.Add(GetTraversalResultLayer(esriNetworkElementType.esriNETTurn, naTraversalResultQuery));
groupLayer.Add(GetTraversalResultLayer(esriNetworkElementType.esriNETEdge, naTraversalResultQuery));
}
private static List<ILayer> GetLayerListByKey(IGroupLayer pGroupLayer, string key)
{
ICompositeLayer comLayer = pGroupLayer as ICompositeLayer;
ILayer tmpLayer;
List<ILayer> listtmpLayer = new List<ILayer>();
for (int j = 0; j <= comLayer.Count - 1; j++)
{
tmpLayer = comLayer.get_Layer(j);
if (tmpLayer is IGroupLayer)
{
List<ILayer> list = GetLayerListByKey((IGroupLayer)tmpLayer, key);
if (list.Count > 0)
listtmpLayer.AddRange(list);
}
else
{
if (tmpLayer.Name.Contains(key) || key == "")
listtmpLayer.Add(tmpLayer);
}
}
return listtmpLayer;
}
private static ILayer GetLayerByName(IGroupLayer pGroupLayer, string layerName)
{
ICompositeLayer comLayer = pGroupLayer as ICompositeLayer;
ILayer tmpLayer;
for (int j = 0; j <= comLayer.Count - 1; j++)
{
tmpLayer = comLayer.get_Layer(j);
if (tmpLayer is IGroupLayer)
{
tmpLayer = GetLayerByName((IGroupLayer)tmpLayer, layerName);
if (tmpLayer != null)
return tmpLayer;
}
else
{
if (tmpLayer.Name == layerName)
return tmpLayer;
}
}
return null;
}
private static ILayer SetLayerVisibleByName(IGroupLayer pGroupLayer, string layerName, bool visible)
{
ICompositeLayer comLayer = pGroupLayer as ICompositeLayer;
ILayer tmpLayer;
for (int j = 0; j <= comLayer.Count - 1; j++)
{
tmpLayer = comLayer.get_Layer(j);
if (tmpLayer is IGroupLayer)
{
tmpLayer = SetLayerVisibleByName((IGroupLayer)tmpLayer, layerName, visible);
if (tmpLayer != null && visible == true)
{
comLayer.get_Layer(j).Visible = visible;
return tmpLayer;
}
}
else
{
if (tmpLayer.Name == layerName)
{
tmpLayer.Visible = visible;
return tmpLayer;
}
}
}
return null;
}
