private IVersion GetMapVersion(ILayer lyr)
{
if (lyr is ICompositeLayer)
{
ICompositeLayer comlyr = lyr as ICompositeLayer;
for (int j = 0; j < comlyr.Count; j++)
{
ILayer lyr2 = comlyr.get_Layer(j);
IVersion ver = GetMapVersion(lyr2);
if (ver != null)
{
return(ver);
}
}
}
else
{
IFeatureLayer flyr = lyr as IFeatureLayer;
if (flyr != null)
{
IDataset dst = flyr.FeatureClass as IDataset;
IDataset ds_ws = dst.Workspace as IDataset;
IVersion source_ver = dst.Workspace as IVersion;
return(source_ver);
}
}
return(null);
}
private static void RecursivelyGetLayers(ILayer pLayer, ref IMap mapFeature,
List <bool> blnVisibleLt, bool blnVisible)
{
if (pLayer is IGroupLayer || pLayer is ICompositeLayer)
{
ICompositeLayer pComLayer = pLayer as ICompositeLayer;
for (int j = pComLayer.Count - 1; j >= 0; j--)
{
ILayer psubLayer = pComLayer.get_Layer(j);
if (pLayer.Visible == false) //if any level is invisible, the lower levels are invisible
{
blnVisible = false;
}
RecursivelyGetLayers(psubLayer, ref mapFeature, blnVisibleLt, blnVisible);
}
}
else
{
if (pLayer is IFeatureLayer) //是否为要素图层
{
mapFeature.AddLayer(pLayer);
blnVisibleLt.Add(blnVisible && pLayer.Visible); //we do this because it's helpful for exporting data to Ipe
}
}
}
private void _CheckLayer(ILayer layer, List <ComboBoxItem> featureLayers)
{
bool layerUsed = false;
if (layer is IGroupLayer && layer is ICompositeLayer)
{
ICompositeLayer groupLayer = (ICompositeLayer)layer;
int layerCount = groupLayer.Count;
for (int i = 0; i < layerCount; i++)
{
ILayer subLayer = groupLayer.get_Layer(i);
_CheckLayer(subLayer, featureLayers);
}
}
else if (layer is IFeatureLayer)
{
if (((IFeatureLayer)layer).FeatureClass != null)
{
featureLayers.Add(new ComboBoxItem()
{
Name = layer.Name, Value = layer
});
layerUsed = true;
}
}
if (!layerUsed)
{
UrbanDelineationExtension.ReleaseComObject(layer);
}
}
private ILayer GetLayerForCompositeLayer(ILayer layer, string lyrName)
{
ILayer pLayer = null;
ICompositeLayer pComLayer = (ICompositeLayer)layer;
for (int i = 0; i < pComLayer.Count; i++)
{
if (pComLayer.get_Layer(i) is ICompositeLayer)
{
pLayer = GetLayerForCompositeLayer(pComLayer.get_Layer(i), lyrName);
if (pLayer != null)
{
return(pLayer);
}
}
else
{
if (pComLayer.get_Layer(i).Name.Equals(lyrName, StringComparison.OrdinalIgnoreCase))
{
pLayer = pComLayer.get_Layer(i);
return(pLayer);
}
}
}
return(pLayer);
}
/// <summary>
/// 窗体加载时触发事件执行
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FormQueryByAttribute_Load(object sender, EventArgs e)
{
// 将当前图层列表清空
comboBoxLayerName.Items.Clear();
// 设置临时变量存储图层名称
string layerName = string.Empty;
// 对Map中的每个图层进行判断并加载名称
for (int i = 0; i < currentMap.LayerCount; i++)
{
// 如果该图层为图层组类型，则分别对所包含的每个图层进行操作
if (currentMap.get_Layer(i) is GroupLayer)
{
// 使用ICompositeLayer接口进行遍历操作
ICompositeLayer compositeLayer = currentMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < compositeLayer.Count; j++)
{
// 将图层的名称添加到comboBoxLayerName控件中
layerName = compositeLayer.get_Layer(j).Name;
comboBoxLayerName.Items.Add(layerName);
}
}
// 如果图层不是图层组类型，则直接添加名字
else
{
layerName = currentMap.get_Layer(i).Name;
comboBoxLayerName.Items.Add(layerName);
}
}
// 将comboBoxLayerName控件的默认选项设置为第一个图层的名称
comboBoxLayerName.SelectedIndex = 0;
// 将comboBoxLayerMethod控件的默认选项设置为第一种选择方式
comboBoxSelectMethod.SelectedIndex = 0;
}
public FormQuery(FormMainOperation formMainOperation)
{
InitializeComponent();
m_FrmMainOper = formMainOperation;
m_pCurMap = m_FrmMainOper(OperationType.GetMap) as IMap;
for (int i = 0; i < m_pCurMap.LayerCount; i++)
{
ILayer pCurLayer = m_pCurMap.get_Layer(i);
if (pCurLayer is GroupLayer)
{
ICompositeLayer curComLayer = pCurLayer as ICompositeLayer;
for (int j = 0; j < curComLayer.Count; j++)
{
CbBox_TargetLayer.Items.Add(curComLayer.get_Layer(j).Name);
CbBox_SourceLayer.Items.Add(curComLayer.get_Layer(j).Name);
}
}
else
{
CbBox_TargetLayer.Items.Add(m_pCurMap.get_Layer(i).Name);
CbBox_SourceLayer.Items.Add(m_pCurMap.get_Layer(i).Name);
}
}
if (CbBox_TargetLayer.Items.Count > 0)
{
pSelectedFeatureLayer = m_pCurMap.get_Layer(0) as IFeatureLayer;
CbBox_TargetLayer.SelectedIndex = 0;
CbBox_SourceLayer.SelectedIndex = 0;
}
CbBox_SelectionSetOperationType.SelectedIndex = 0;
}
/// <summary>
/// 获取当前地图文档所有图层集合
/// </summary>
/// <param name="pMap"></param>
/// <returns></returns>
public static List <ILayer> GetLayers(IMap pMap)
{
ILayer plyr = null;
List <ILayer> pLstLayers = null;
try
{
pLstLayers = new List <ILayer>();
for (int i = 0; i < pMap.LayerCount; i++)
{
if ((pMap.get_Layer(i) is IFeatureLayer) && !(pMap.get_Layer(i) is GroupLayer))
{
plyr = pMap.get_Layer(i);
pLstLayers.Add(plyr);
}
if (pMap.get_Layer(i) is GroupLayer)
{
ICompositeLayer pComLayer = pMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < pComLayer.Count; j++)
{
plyr = pComLayer.get_Layer(j);
pLstLayers.Add(plyr);
}
}
}
}
catch (Exception ex)
{ }
return(pLstLayers);
}
public static ILayer GetLayerByName(ICompositeLayer compositeLayer, string layerName,
bool isFeatureLayer = false)
{
try
{
for (int i = 0; i < compositeLayer.Count; i++)
{
ILayer layer = compositeLayer.Layer[i];
if (layer is IGroupLayer)
{
return(GetLayerByName(layer as ICompositeLayer, layerName, isFeatureLayer));
}
if (isFeatureLayer && (layer is IFeatureLayer) == false)
{
continue;
}
if (layer.Name == layerName)
{
return(layer);
}
}
}
catch (Exception ex)
{
return(null);
}
return(null);
}
public static IFeatureLayer GetLayerByFeatureClassName(ICompositeLayer compositeLayer, string featureClassName)
{
try
{
for (int i = 0; i < compositeLayer.Count; i++)
{
ILayer layer = compositeLayer.Layer[i];
if (layer is IGroupLayer)
{
return(GetLayerByFeatureClassName(layer as ICompositeLayer, featureClassName));
}
if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
IDataset dataset = featureClass as IDataset;
if (dataset != null)
{
string[] strArray = dataset.Name.Split(new char[] { '.' });
string str = strArray[strArray.Length - 1];
if (str == featureClassName)
{
return(layer as IFeatureLayer);
}
}
}
}
}
catch (Exception ex)
{
return(null);
}
return(null);
}
private ILayer GetLayerByName(string sName, IMap pmap)
{
ILayer pLayer;
for (int i = 0; i < pmap.LayerCount; i++)
{
pLayer = pmap.get_Layer(i);
if (pLayer is ICompositeLayer)
{
ICompositeLayer pCLayer = pLayer as ICompositeLayer;
for (int j = 0; j < pCLayer.Count; j++)
{
pLayer = pCLayer.get_Layer(j);
if (pLayer is IFeatureLayer)
{
if (pLayer.Name == sName)
{
return(pLayer);
}
}
}
}
else if (pLayer is IFeatureLayer)
{
if (pLayer.Name == sName)
{
return(pLayer);
}
}
}
return(null);
}
public static bool ExistFeatureClass(IMap map, IFeatureClass featureClass)
{
for (int i = 0; i < map.LayerCount; i++)
{
ILayer pLayer = map.Layer[i];
if (pLayer is IGroupLayer)
{
ICompositeLayer pCompositeLayer = pLayer as ICompositeLayer;
for (int j = 0; j < pCompositeLayer.Count; j++)
{
ILayer pgLayer = pCompositeLayer.Layer[j];
IFeatureLayer pgFeatureLayer = pgLayer as IFeatureLayer;
if (pgFeatureLayer == null)
{
continue;
}
if (pgFeatureLayer.FeatureClass == featureClass)
{
return(true);
}
}
}
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
if (pFeatureLayer == null)
{
continue;
}
if (pFeatureLayer.FeatureClass == featureClass)
{
return(true);
}
}
return(false);
}
/// <summary>
/// 在地图中根据图层名称获得矢量图层。
/// </summary>
/// <param name="map">当前地图</param>
/// <param name="layerName">图层名称</param>
/// <returns>IFeatureLayer接口的矢量图层对象</returns>
private IFeatureLayer GetFeatureLayerByName(IMap map, string layerName)
{
//对地图中的图层进行遍历
for (int i = 0; i < map.LayerCount; i++)
{
//如果该图层为图层组类型，则分别对所包含的每个图层进行操作
if (map.get_Layer(i) is GroupLayer)
{
//使用ICompositeLayer接口进行遍历操作
ICompositeLayer compositeLayer = map.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < compositeLayer.Count; j++)
{
//如果图层名称为所要查询的图层名称，则返回IFeatureLayer接口的矢量图层对象
if (compositeLayer.get_Layer(j).Name == layerName)
{
return((IFeatureLayer)compositeLayer.get_Layer(j));
}
}
}
//如果图层不是图层组类型，则直接进行判断
else
{
if (map.get_Layer(i).Name == layerName)
{
return((IFeatureLayer)map.get_Layer(i));
}
}
}
return(null);
}
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
listBoxFields.Items.Clear();
listBoxValues.Items.Clear();
IField field; //设置临时变量存储使用IField接口的对象
for (int i = 0; i < currentMap.LayerCount; i++)
{
if (currentMap.get_Layer(i) is GroupLayer)
{
ICompositeLayer compositeLayer = currentMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < compositeLayer.Count; j++)
{
//判断图层的名称是否与comboBoxLayerName控件中选择的图层名称相同
if (compositeLayer.get_Layer(j).Name == comboBox1.SelectedItem.ToString())
{
//如果相同则设置为整个窗体所使用的IFeatureLayer接口对象
currentFeatureLayer = compositeLayer.get_Layer(j) as IFeatureLayer;
break;
}
}
}
else
{
//判断图层的名称是否与comboBoxLayerName中选择的图层名称相同
if (currentMap.get_Layer(i).Name == comboBox1.SelectedItem.ToString())
{
//如果相同则设置为整个窗体所使用的IFeatureLayer接口对象
currentFeatureLayer = currentMap.get_Layer(i) as IFeatureLayer;
break;
}
}
}
}
public static IFeatureLayer GetLayerByFeatureClassAliasName(ICompositeLayer compositeLayer,
string featureClassName)
{
try
{
for (int i = 0; i < compositeLayer.Count; i++)
{
ILayer layer = compositeLayer.Layer[i];
if (layer is IGroupLayer)
{
return(GetLayerByFeatureClassAliasName(layer as ICompositeLayer, featureClassName));
}
if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
if (featureLayer.FeatureClass.AliasName == featureClassName)
{
return(featureLayer);
}
}
}
}
catch (Exception ex)
{
return(null);
}
return(null);
}
//勾选可见图层时
private void VisiableOnly_CheckedChanged(object sender, EventArgs e)
{
TargetLayer.Items.Clear();
string layerName;
//当勾选时
if (VisiableOnly.CheckState == CheckState.Checked)
{
for (int i = 0; i < currentMap.LayerCount; i++)
{
if (currentMap.get_Layer(i) is IFeatureLayer && currentMap.get_Layer(i).Visible == true)
{
if (currentMap.get_Layer(i) is GroupLayer)
{
ICompositeLayer pCompositeLayer = currentMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < pCompositeLayer.Count; j++)
{
layerName = pCompositeLayer.get_Layer(i).Name;
TargetLayer.Items.Add(layerName);
TargetLayer.Refresh();
}
}
else
{
layerName = currentMap.get_Layer(i).Name;
TargetLayer.Items.Add(layerName);
TargetLayer.Refresh();
}
}
}
}
//未勾选时
if (VisiableOnly.CheckState == CheckState.Unchecked)
{
for (int i = 0; i < currentMap.LayerCount; i++)
{
if (currentMap.get_Layer(i) is IFeatureLayer)
{
if (currentMap.get_Layer(i) is GroupLayer)
{
ICompositeLayer pCompositeLayer = currentMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < pCompositeLayer.Count; j++)
{
layerName = pCompositeLayer.get_Layer(i).Name;
TargetLayer.Items.Add(layerName);
TargetLayer.Refresh();
}
}
else
{
layerName = currentMap.get_Layer(i).Name;
TargetLayer.Items.Add(layerName);
TargetLayer.Refresh();
}
}
}
}
SourceLayerSelect.SelectedIndex = 0;
}
//若果已经有图层,则相应的chexbox项应该被选中
private void judeLayer()
{
int count = MainFrom.m_mapControl.LayerCount;
if (count == 0)
{
return;
}
for (int i = 0; i < count; i++)
{
ILayer pGL = MainFrom.m_mapControl.get_Layer(i);
if (pGL is IGroupLayer)
{
ICompositeLayer pGroupLayer = pGL as ICompositeLayer;
for (int j = 0; j < pGroupLayer.Count; j++)
{
ILayer pCompositeLayer;
pCompositeLayer = pGroupLayer.get_Layer(j);
for (int y = 0; y < exCheckedListBox1.Items.Count; y++)
{
string layerName = exCheckedListBox1.Items[y].ToString();
if (!layerName.Equals("降水量"))
{
int index = layerName.LastIndexOf(".");
if (layerName.Substring(index) == ".shp")
{
layerName = layerName.Substring(0, index);
}
}
if (layerName == pCompositeLayer.Name)
{
//后台选中 改变checkState
exCheckedListBox1.SetItemChecked(y, true);
}
}
}
}
else
{
for (int y = 0; y < exCheckedListBox1.Items.Count; y++)
{
string layerName = exCheckedListBox1.Items[y].ToString();
if (!layerName.Equals("降水量"))
{
int index = layerName.LastIndexOf(".");
if (layerName.Substring(index) == ".shp")
{
layerName = layerName.Substring(0, index);
}
}
if (layerName == pGL.Name)
{
//后台选中 改变checkState
exCheckedListBox1.SetItemChecked(y, true);
}
}
}
}
}
//而
private void checkBox1_CheckedChanged(object sender, EventArgs e)
{
string layerName;
comboBox1.Items.Clear();
if (checkBox1.CheckState == CheckState.Checked)
{
for (int i = 0; i < currentMap.LayerCount; i++)
{
if (currentMap.get_Layer(i) is IFeatureLayer && currentMap.get_Layer(i).Visible == true)
{
if (currentMap.get_Layer(i) is GroupLayer)
{
ICompositeLayer pCompositeLayer = currentMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < pCompositeLayer.Count; j++)
{
layerName = pCompositeLayer.get_Layer(i).Name;
comboBox1.Items.Add(layerName);
comboBox1.Refresh();
}
}
else
{
layerName = currentMap.get_Layer(i).Name;
comboBox1.Items.Add(layerName);
comboBox1.Refresh();
}
}
}
}
//未勾选时
if (checkBox1.CheckState == CheckState.Unchecked)
{
for (int i = 0; i < currentMap.LayerCount; i++)
{
if (currentMap.get_Layer(i) is IFeatureLayer)
{
if (currentMap.get_Layer(i) is GroupLayer)
{
ICompositeLayer pCompositeLayer = currentMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < pCompositeLayer.Count; j++)
{
layerName = pCompositeLayer.get_Layer(i).Name;
comboBox1.Items.Add(layerName);
comboBox1.Refresh();
}
}
else
{
layerName = currentMap.get_Layer(i).Name;
comboBox1.Items.Add(layerName);
comboBox1.Refresh();
}
}
}
}
comboBox1.SelectedIndex = 0;
comboBox2.SelectedIndex = 0;
}
//======================================================================================================
#region 判断要素是否在同一图层以及图层的编辑状态
//===================================================================================================
//陈胜鹏 2009-08-19 添加
/// <summary>
/// 从图面上获取选中要素所在数据集的工作空间，判断是否开启编辑
/// </summary>
/// <param name="pMap">当前加载了数据的地图对象</param>
/// <returns></returns>
private bool GetDatasetEditState(ESRI.ArcGIS.Carto.IMap pMap)
{
int pSameLyr = 0; //记录要素是否为同层
ILayer pLayer = null;
//判断选择的要素是否处于同一个图层
for (int i = 0; i < pMap.LayerCount; i++)
{
IFeatureLayer pFeatLyr = null;
IFeatureSelection pFeatSel = null;
pLayer = pMap.get_Layer(i);
if (pLayer is IGroupLayer)
{
if (pLayer.Name == "示意图")
{
continue;
}
ICompositeLayer pComLayer = pLayer as ICompositeLayer;
for (int j = 0; j < pComLayer.Count; j++)
{
ILayer mLayer = pComLayer.get_Layer(j);
pFeatLyr = mLayer as IFeatureLayer;
if (pFeatLyr != null)
{
pFeatSel = pFeatLyr as IFeatureSelection;
if (pFeatSel.SelectionSet.Count > 0)
{
pSameLyr = pSameLyr + 1;
m_MergeLayer = pFeatLyr;//当只有一个图层被选中时，pFeatLyr就是要进行融合的目标图层
}
}
}
}
pFeatLyr = pLayer as IFeatureLayer;
if (pFeatLyr != null)
{
pFeatSel = pFeatLyr as IFeatureSelection;
if (pFeatSel.SelectionSet.Count > 0)
{
pSameLyr = pSameLyr + 1;
m_MergeLayer = pFeatLyr;//当只有一个图层被选中时，pFeatLyr就是要进行融合的目标图层
}
}
}
//如果选择的要素所在的层数不是1，即要素不在同一个层
if (pSameLyr != 1)
{
return(false);
}
//一系列的QI后获得IWorkspaceEdit接口对象pWSE
IFeatureClass pFeatCls = m_MergeLayer.FeatureClass as IFeatureClass;
IDataset pDS = pFeatCls as IDataset;
IWorkspace pWs = pDS.Workspace as IWorkspace;
IWorkspaceEdit pWSE = pWs as IWorkspaceEdit;
return(pWSE.IsBeingEdited()); //返回编辑状态
}
//在窗体加载时执行本函数，加载所有具有选择要素的图层
private void FormSelection_Load(object sender, EventArgs e)
{
this.StartPosition = FormStartPosition.CenterScreen;
IFeatureLayer featureLayer; //设置临时变量存储当前矢量图层
string layerName; //设置临时变量存储当前图层的名称
TreeNode treeNode; //设置临时变量存储当前树节点的信息
//对Map中的每个图层进行判断并加载图层名称
for (int i = 0; i < currentMap.LayerCount; i++)
{
if (currentMap.get_Layer(i) is IFeatureLayer)
{
}
else
{
break;
}
//如果该图层为图层组类型，则分别对所包含的每个图层进行操作
if (currentMap.get_Layer(i) is GroupLayer)
{
//使用ICompositeLayer接口进行遍历操作
ICompositeLayer compositeLayer = currentMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < compositeLayer.Count; j++)
{
//得到图层的名称
layerName = compositeLayer.get_Layer(j).Name;
//得到矢量图层对象的IFeatureLayer接口
featureLayer = (IFeatureLayer)compositeLayer.get_Layer(j);
//如果该图层选择集中的要素不为空，则在TreeView控件中添加一个树节点
if (((IFeatureSelection)featureLayer).SelectionSet.Count > 0)
{
//新建一个树节点，将图层名称作为树节点的名称
treeNode = new TreeNode(layerName);
//利用树节点的Tag属性，存储当前图层的IFeatureLayer接口信息
treeNode.Tag = featureLayer;
//将新建的树节点添加到TreeView控件中的根节点下
treeViewLayers.TopNode.Nodes.Add(treeNode);
}
}
}
// 如果图层不是图层组类型，则同样在TreeView控件中的根节点下添加节点
else
{
layerName = currentMap.get_Layer(i).Name;
featureLayer = (IFeatureLayer)currentMap.get_Layer(i);
if (((IFeatureSelection)featureLayer).SelectionSet.Count > 0)
{
treeNode = new TreeNode(layerName);
treeNode.Tag = featureLayer;
treeViewLayers.TopNode.Nodes.Add(treeNode);
}
}
}
//添加完节点后将根节点展开以显示所有的图层
treeViewLayers.TopNode.Expand();
//通过IMap接口的SelectionCount属性可以获取被选择要素的数量
labelMapSelectionCount.Text = "当前地图共选择了 " + currentMap.SelectionCount + " 个要素。";
}
/// <summary>
/// This recursive method will Populate the treeview.
/// </summary>
/// <param name="layer">The current layer</param>
/// <param name="parentNode">The parent TreeNode</param>
private void PopulateTree(ILayer layer, TreeNode parentNode)
{
TreeNode node = new TreeNode(layer.Name);
ILegendInfo legendInfo = layer as ILegendInfo;
if (legendInfo != null)
{
ILegendGroup legendGroup;
for (int i = 0; i < legendInfo.LegendGroupCount; ++i)
{
ILegendClass legendClass;
legendGroup = legendInfo.get_LegendGroup(i);
for (int j = 0; j < legendGroup.ClassCount; ++j)
{
IAgEsri3dSymbolHelper symbolHelper = this.m_Renderer.Context.CreateObject("STKesriDisplay10.AgEsri3dSymbolHelper") as IAgEsri3dSymbolHelper;//new AgEsri3dSymbolHelperClass();
symbolHelper.SetUseSymbolSize(true);
legendClass = legendGroup.get_Class(j);
TreeNode legendClassNode = new TreeNode(legendClass.Label);
ISymbol symbol;
symbol = legendClass.Symbol;
if (symbolHelper != null)
{
int bmp;
bmp = symbolHelper.ToBitmap(symbol);
IntPtr bmpPtr = new IntPtr(bmp);
legendClassNode.ImageIndex = this.ImageList.Images.Count;
legendClassNode.SelectedImageIndex = legendClassNode.ImageIndex;
Bitmap bitmap = Bitmap.FromHbitmap(bmpPtr);
bitmap.MakeTransparent(Color.FromArgb(85, 85, 85));
bitmap.SetResolution(30, 30);
this.ImageList.Images.Add(StandardizeBitmap((bitmap)));
}
node.Nodes.Add(legendClassNode);
}
}
}
node.ImageIndex = NOIMAGE;
parentNode.Nodes.Add(node);
node.Checked = (layer.Visible && layer.Valid);
node.Tag = layer;
ICompositeLayer subLayer = layer as ICompositeLayer;
if (subLayer != null)
{
for (int i = 0; i < subLayer.Count; ++i)
{
PopulateTree(subLayer.get_Layer(i), node);
}
}
}
/// <summary>
/// 双击后，通过显示的记录查找出指定层的指定无素
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DataCheckGridDoubleClick(object sender, System.EventArgs e)
{
DataGridView view = (DataGridView)sender; //将当前操作的对象转成控件对象，以方便操作
string temp = view.SelectedCells[0].Value.ToString(); //得到点击行的第一个单元格内容
string className = ""; //要素类的名称
int OrginID = 0; //源要素类的要素ID
int DestID = 0; //目标要素ID
char[] p = { ' ' }; //以空格为分割点
char[] s = { '：' }; //以：为分割点
string[] para = temp.Split(p);
className = para[0]; //名称
string[] org = para[1].Split(s); //得到源ID串
OrginID = Convert.ToInt32(org[1]); //源ID
string[] des = para[2].Split(s); //目标源ID串
DestID = Convert.ToInt32(des[1]); //目标ID
IFeature fu = null; //得到要素
int n = _AppHk.MapControl.Map.LayerCount;
ISpatialReference pSpatialRef = null;
if (n == 0)
{
return;
}
//遍历找出我们指定层
for (int S = 0; S < n; S++)
{
ILayer layer = _AppHk.MapControl.Map.get_Layer(S);
//判别是不是组，如果是，就从组中取一个层
if (layer is IGroupLayer)
{
ICompositeLayer C_layer = layer as ICompositeLayer;//得到组合图层
for (int c = 0; c < C_layer.Count; c++)
{
ILayer temp_layer = C_layer.get_Layer(c);
IFeatureLayer F_layer = temp_layer as IFeatureLayer;
IDataset set = F_layer.FeatureClass as IDataset;
if (className == set.Name)
{
if (pSpatialRef == null)
{
pSpatialRef = (set as IGeoDataset).SpatialReference;
}
m_CurLayer = temp_layer;
//IFeatureLayer f_layer = temp_layer as IFeatureLayer;//转成对应的要素层
fu = F_layer.FeatureClass.GetFeature(OrginID);//得到要素
break;
}
}
}
}
if (fu != null)
{
_AppHk.MapControl.Map.ClearSelection(); //每次进来前先清除之前选择过的
_AppHk.MapControl.Map.SelectFeature(m_CurLayer, fu); //在对应的层上选择指定的元素
SysCommon.Gis.ModGisPub.ZoomToFeature(_AppHk.MapControl, fu, pSpatialRef); //定位到相应的层
}
}
/// <summary>
/// Creates a new instance of <see cref="TableOfContentsItem"/>.
/// </summary>
public TableOfContentsItem(ICompositeLayer layer)
{
if (layer == null)
{
throw new ArgumentNullException("layer");
}
_tocObject = layer;
_descriptor = Descriptor.CompositeLayer;
}
private void FillLayerBox()
{
this.LayerBox.Items.Clear();
this.ADArray.Clear();
this.SqlBox.Text = "";
int layerCount = m_context.FocusMap.LayerCount;
for (int i = 0; i < layerCount; i++)
{
ILayer layer = m_context.FocusMap.get_Layer(i);
if (layer is IGroupLayer)
{
ICompositeLayer compositeLayer = (ICompositeLayer)layer;
if (compositeLayer == null)
{
return;
}
int count = compositeLayer.Count;
for (int j = 0; j < count; j++)
{
ILayer layer2 = compositeLayer.get_Layer(j);
string text = layer2.Name.ToString();
if (this.radioButton1.Checked)
{
if (this.pPipeCfg.IsPipelineLayer(layer2.Name, enumPipelineDataType.Point))
{
this.LayerBox.Items.Add(text);
}
}
else if (this.pPipeCfg.IsPipelineLayer(text, enumPipelineDataType.Line))
{
this.LayerBox.Items.Add(text);
}
}
}
else if (layer is IFeatureLayer)
{
string text = layer.Name.ToString();
if (this.radioButton1.Checked)
{
if (this.pPipeCfg.GetBasicLayerInfo(((IFeatureLayer)layer).FeatureClass) != null)
{
this.LayerBox.Items.Add(text);
}
}
else if (this.pPipeCfg.GetBasicLayerInfo(((IFeatureLayer)layer).FeatureClass) != null)
{
this.LayerBox.Items.Add(text);
}
}
}
if (this.LayerBox.Items.Count > 0)
{
this.LayerBox.SelectedIndex = 0;
return;
}
}
private IEnvelope pEnv; //记录数据视图的Extent
/// <summary>
/// 同步鹰眼
/// </summary>
private void SynchronizeEagleEye()
{
try
{
if (EagleEyeMapControl.LayerCount > 0)
{
EagleEyeMapControl.ClearLayers();
}
//设置鹰眼和主地图的坐标系统一致
EagleEyeMapControl.SpatialReference = Map.SpatialReference;
for (int i = Map.LayerCount - 1; i >= 0; i--)
{
//使鹰眼视图与数据视图的图层上下顺序保持一致
ILayer pLayer = Map.get_Layer(i);
if (pLayer is IGroupLayer || pLayer is ICompositeLayer)
{
ICompositeLayer pCompositeLayer = (ICompositeLayer)pLayer;
for (int j = pCompositeLayer.Count - 1; j >= 0; j--)
{
ILayer pSubLayer = pCompositeLayer.get_Layer(j);
IFeatureLayer pFeatureLayer = pSubLayer as IFeatureLayer;
if (pFeatureLayer != null)
{
//由于鹰眼地图较小，所以过滤点图层不添加
if (pFeatureLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryPoint &&
pFeatureLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryMultipoint)
{
EagleEyeMapControl.AddLayer(pLayer);
}
}
}
}
else
{
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
if (pFeatureLayer != null)
{
if (pFeatureLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryPoint &&
pFeatureLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryMultipoint)
{
EagleEyeMapControl.AddLayer(pLayer);
}
}
}
//设置鹰眼地图全图显示
EagleEyeMapControl.Extent = Map.FullExtent;
pEnv = Map.Extent as IEnvelope;
DrawRectangle(pEnv);
EagleEyeMapControl.ActiveView.Refresh();
}
}
catch (Exception e)
{
ShowError("鹰眼地图刷新失败\n" + e.Message);
}
}
private void SynchronizeEagleEye() //加载鹰眼视图
{
if (EagleEyemapcontrol.LayerCount > 0) //清除原有图层
{
EagleEyemapcontrol.ClearLayers();
}
EagleEyemapcontrol.SpatialReference = axMapControl1.SpatialReference;//鹰眼视图坐标系和主地图坐标系相同
for (int i = axMapControl1.LayerCount - 1; i >= 0; i--)
{
ILayer player = axMapControl1.get_Layer(i); //获取第i个视图
if (player is IGroupLayer || player is ICompositeLayer) //判断此视图是否内置还有图层
{
ICompositeLayer pcompositelayer = (ICompositeLayer)player; //强制转换
for (int j = pcompositelayer.Count - 1; j >= 0; j--)
{
ILayer psublayer = pcompositelayer.get_Layer(j); //获取此视图中第i个图层
IFeatureLayer pfeaturelayer = psublayer as IFeatureLayer; //获得此图层作为要素图层
if (pfeaturelayer == null)
{
continue; //此图层为空则返回进行下一个图层操作
}
if (pfeaturelayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryPoint && pfeaturelayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryMultipoint)
{
EagleEyemapcontrol.AddLayer(player);
}
}
}
else
{
IFeatureLayer pfeaturelayer1 = new FeatureLayer();
pfeaturelayer1 = player as IFeatureLayer;
if (pfeaturelayer1 == null)
{
continue;
}
if (pfeaturelayer1 != null)
{
if (pfeaturelayer1.FeatureClass == null)
{
return;
}
else
{
if (pfeaturelayer1.FeatureClass.ShapeType != esriGeometryType.esriGeometryPoint && pfeaturelayer1.FeatureClass.ShapeType != esriGeometryType.esriGeometryMultipoint)
{
EagleEyemapcontrol.AddLayer(player);
}
}
}
}
EagleEyemapcontrol.Extent = axMapControl1.FullExtent;
pEnv = axMapControl1.Extent;
DrawRectangle(pEnv);//定义一个函数，在鹰眼视图上画矩形框
EagleEyemapcontrol.Refresh();
}
}
private void cBoxExZTLX_SelectedIndexChanged(object sender, EventArgs e)
{
if (cBoxExZTLX.Text == "")
{
return;
}
for (int i = 0; i < cMap.LayerCount; i++)
{
if (cMap.get_Layer(i) is IGroupLayer)
{
int idex = cMap.get_Layer(i).Name.IndexOf('_');
string ztlx = cMap.get_Layer(i).Name;//.Substring(0, idex);
if (cBoxExZTLX.Text != ztlx)
{
continue;
}
namelist.Clear();
listView1.Items.Clear();
ICompositeLayer cmp = cMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < cmp.Count; j++)
{
listView1.Items.Add(cmp.get_Layer(j).Name);
}
}
}
cXmlDoc = new XmlDocument();
if (cXmlDoc != null && File.Exists(cPath))
{
cXmlDoc.Load(cPath);
XmlNodeList xnl = cXmlDoc.GetElementsByTagName("SubMapType");
foreach (XmlNode xn in xnl)
{
if ((xn as XmlElement).GetAttribute("ItemName").ToString() != "森林资源现状图")
{
continue;
}
for (int i = 0; i < xn.ChildNodes.Count; i++)
{
for (int k = 0; k < listView1.Items.Count; k++)
{
if (xn.ChildNodes[i].Attributes["sItemName"].Value == listView1.Items[k].Text)
{
listView1.Items[k].Checked = true;
}
}
}
}
cXmlDoc = null;
}
}
/// <summary>
/// 更新所有数据事件
/// </summary>
public void UpdateData()
{
IFeatureLayer featureLayer; //设置临时变量存储当前矢量图层
string layerName; //设置临时变量存储当前图层的名称
TreeNode treeNode; //设置临时变量存储当前树节点的信息
//首先清空DataGridView中的行和列
dataGridView.Columns.Clear();
dataGridView.Rows.Clear();
treeViewLayers.TopNode.Nodes.Clear(); // 清空树节点
//对Map中的每个图层进行判断并加载图层名称
for (int i = 0; i < currentMap.LayerCount; i++)
{
//如果该图层为图层组类型，则分别对所包含的每个图层进行操作
if (currentMap.get_Layer(i) is GroupLayer)
{
//使用ICompositeLayer接口进行遍历操作
ICompositeLayer compositeLayer = currentMap.get_Layer(i) as ICompositeLayer;
for (int j = 0; j < compositeLayer.Count; j++)
{
//得到图层的名称
layerName = compositeLayer.get_Layer(j).Name;
//得到矢量图层对象的IFeatureLayer接口
featureLayer = (IFeatureLayer)compositeLayer.get_Layer(j);
//如果该图层选择集中的要素不为空，则在TreeView控件中添加一个树节点
if (((IFeatureSelection)featureLayer).SelectionSet.Count > 0)
{
//新建一个树节点，将图层名称作为树节点的名称
treeNode = new TreeNode(layerName);
//利用树节点的Tag属性，存储当前图层的IFeatureLayer接口信息
treeNode.Tag = featureLayer;
//将新建的树节点添加到TreeView控件中的根节点下
treeViewLayers.TopNode.Nodes.Add(treeNode);
}
}
}
//如果图层不是图层组类型，则同样在TreeView控件中的根节点下添加节点
else
{
layerName = currentMap.get_Layer(i).Name;
featureLayer = (IFeatureLayer)currentMap.get_Layer(i);
if (((IFeatureSelection)featureLayer).SelectionSet.Count > 0)
{
treeNode = new TreeNode(layerName);
treeNode.Tag = featureLayer;
treeViewLayers.TopNode.Nodes.Add(treeNode);
}
}
}
//添加完节点后将根节点展开以显示所有的图层
treeViewLayers.TopNode.Expand();
//通过IMap接口的SelectionCount属性可以获取被选择要素的数量
labelMapSelectionCount.Text = "当前地图共选择了 " + currentMap.SelectionCount + " 个要素。";
}
private void ExpandGroupLayer(IGroupLayer pGroupLayer)
{
ICompositeLayer pComLayer = pGroupLayer as ICompositeLayer;
for (int i = 0; i < pComLayer.Count; i++)
{
IFeatureLayer pFlayer = pComLayer.get_Layer(i) as IFeatureLayer;
ExpandLayer(pFlayer);
}
}
/// <summary>
/// 获取要素的集合
/// </summary>
/// <param name="pMap">地图要素</param>
/// <param name="pLayer">图层</param>
/// <param name="LyrCol">定义的集合类型</param>
/// <returns></returns>
public static Collection <object> GetFeaLyrCol(IMap pMap, ILayer pLayer, Collection <object> LyrCol)
{
ILayer pTempLyr = null;
ICompositeLayer pCompositeLayer = null;
if (LyrCol == null)
{
LyrCol = new Collection <object>();
}
if (pMap == null)
{
if (pLayer == null)
{
return(null);
}
else
{
if (pLayer is IGroupLayer)
{
pCompositeLayer = pLayer as ICompositeLayer;
for (int i = 0; i < pCompositeLayer.Count; i++)
{
GetFeaLyrCol(null, pCompositeLayer.get_Layer(i), LyrCol);
}
}
else
{
LyrCol.Add(pLayer);
}
}
}
else
{
for (int i = 0; i < pMap.LayerCount; i++)
{
pTempLyr = pMap.get_Layer(i);
if (pTempLyr is IGroupLayer)
{
if (pTempLyr.Name != "示意图")
{
GetFeaLyrCol(null, pTempLyr, LyrCol);
}
}
else
{
LyrCol.Add(pTempLyr);
}
}
}
return(LyrCol);
}
private static void ChangeGroupLayerVisibility(ICompositeLayer grpLayer, bool visible)
{
for (int i = 0; i < grpLayer.Count; i++)
{
grpLayer.Layer[i].Visible = visible;
if (grpLayer.Layer[i] is ICompositeLayer)
{
ChangeGroupLayerVisibility((ICompositeLayer)grpLayer.Layer[i], visible);
}
}
}
/// <summary>
/// Check for sub layers that have a idaho id for a layer name
/// </summary>
/// <param name="layer"></param>
/// <returns></returns>
private static List<string> CheckSubLayers(ICompositeLayer layer)
{
var output = new List<string>();
if (layer != null && layer.Count > 1)
{
for (int i = 0; i < layer.Count; i++)
{
var tempLayer = layer.Layer[i];
if (IdahoIdPattern.IsMatch(tempLayer.Name))
{
output.Add(tempLayer.Name);
}
}
}
return output;
}
private static string GetFullName(ICompositeLayer parent, ILayer layer, string separator)
{
for (int i = 0; i < parent.Count; i++)
{
if (parent.Layer[i] == layer)
return layer.Name;
if (!(parent.Layer[i] is ICompositeLayer))
continue;
string name = GetFullName((ICompositeLayer)parent.Layer[i], layer, separator);
if (name != null)
return parent.Layer[i].Name + separator + name;
}
return null;
}
