wangguanjie
/
NDBGJK5.0
4
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
年度变更建库软件5.0版本
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.
2 Commits
4 Branches
0 Tags
121 MiB
 
 
Tag: Branch: Tree: LMJ
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'LMJ'
${ noResults }
NDBGJK5.0/Kingo.Plugins/Kingo.Plugin.MapView/Views/DataCalalog/UCLayerTree.cs

2686 lines
104 KiB
Raw Permalink Blame History

using DevExpress.XtraBars;
using DevExpress.XtraEditors;
using DevExpress.XtraTreeList;
using DevExpress.XtraTreeList.Columns;
using DevExpress.XtraTreeList.Nodes;
using ESRI.ArcGIS.Carto;
using ESRI.ArcGIS.Controls;
using ESRI.ArcGIS.Display;
using ESRI.ArcGIS.esriSystem;
using ESRI.ArcGIS.Geodatabase;
using ESRI.ArcGIS.Geometry;
using ESRI.ArcGIS.SystemUI;
using KGIS.Framework.AE;
using KGIS.Framework.Commands;
using KGIS.Framework.Maps;
using KGIS.Framework.Menus.Entities;
using KGIS.Framework.Menus.ServicesInvokes;
using KGIS.Framework.Platform;
using KGIS.Framework.Utils;
using KGIS.Framework.Utils.ExtensionMethod;
using KGIS.Framework.Utils.Helper;
using KGIS.Framework.Views;
using Kingo.Framework.LayerStyleConvert.Common;
using Kingo.Framework.LayerStyleConvert.XSDClass;
using Kingo.PluginServiceInterface;
using Kingo.PluginServiceInterface.Helper;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using UIShell.OSGi;
namespace Kingo.Plugin.MapView.Views.DataCalalog
{
public partial class UCLayerTree : UserControl, IDockPanel, IDataCatalogService
{
private ICommandManager _CmdManager;
private IMapService _MapService;
private ILayerPropertyService _LayerPropertyService = null;
private EngineEditor _Edit = null;
List<LayerCfg> _listCfg = null;
public UCLayerTree()
{
InitializeComponent();
this.AllowDrop = true;
this.trlProject.AllowDrop = true;
this.trlProject.OptionsDragAndDrop.AcceptOuterNodes = true;
Title = "图层目录";
DockWidth = 330;
DefaultArea = KGIS.Framework.Views.DockStyle.DockLeft;
DockAreas = KGIS.Framework.Views.DockStyle.DockLeft | KGIS.Framework.Views.DockStyle.DockRight | KGIS.Framework.Views.DockStyle.DockBottom | KGIS.Framework.Views.DockStyle.DockTop;
ShowCloseButton = false;
ShowAutoHideButton = true;
//string strMxdPath = System.IO.Path.Combine(SysAppPath.GetCurrentAppPath() + "工作空间\\模板\\新建变更工程\\LayerSymbolCfg" + ".xml");
//if (File.Exists(strMxdPath))
//{
// LayerCfg StrLayerInfo = SerializeAPI.DeserializeToObject2<LayerCfg>(strMxdPath);
// if (StrLayerInfo != null)
// _listCfg = StrLayerInfo.GetAllItem();
//}
bool IsOnlySave = false;
_Edit = new EngineEditorClass();
_Edit.OnStopEditing += (b) =>
{
if (mCurrentEditorNode == null) return;
if (!IsOnlySave)
{
mCurrentEditorNode.SetValue("IsEdit", false);
mCurrentEditorNode.SetValue("ImgIndex", 0);
}
IsOnlySave = false;
};
_Edit.OnSaveEdits += () =>
{
IsOnlySave = true;
};
//打开折叠
trlProject.AfterExpand += (sender1, e1) =>
{
try
{
//bool? IsExpanded = (bool?)e1.Node.GetValue("Expanded");
string name = e1.Node["LayerName"].ToTrim();
var item = Layers.FirstOrDefault(f => f.LayerName == name);
if (item == null) return;
item.Expanded = e1.Node.Expanded;
}
catch (Exception ex)
{
LogAPI.Debug(ex.Message);
}
};
//关闭折叠
trlProject.AfterCollapse += (sender2, e2) =>
{
try
{
string layername = e2.Node["LayerName"].ToTrim();
var item = Layers.FirstOrDefault(f => f.LayerName == layername);
item.Expanded = e2.Node.Expanded;
}
catch (Exception ex)
{
LogAPI.Debug(ex.Message);
}
};
trlProject.NodeCellStyle += (sender1, e1) =>
{
try
{
//TreeListColumn column2 = trlProject.Columns.ColumnByName("LayerEditable");
bool? isEdit = e1.Node == null ? null : (bool?)e1.Node.GetValue("IsEdit");
if (isEdit == true && e1.Column.FieldName == "LayerName")
{
e1.Appearance.ForeColor = Color.Red;
e1.Appearance.FontStyleDelta = FontStyle.Bold;
}
else if (e1.Column != null && e1.Column.FieldName == "LayerName" && isEdit == false)
{
e1.Appearance.ForeColor = Color.Black;
e1.Appearance.FontStyleDelta = FontStyle.Regular;
}
}
catch (Exception ex)
{
LogAPI.Debug(ex.Message);
}
};
Platform.Instance.NotifyMsgEven2 += (o) =>
{
switch (o.MsgType)
{
case "RefreshLayer":
//InitTreeNode(_MapService.getAxMapControl().Map);
break;
default:
break;
}
};
}
List<LayerCfg> Layers = new List<LayerCfg>();
private LayerCfg _CurrentLayers;
public object CurrentLayers
{
get
{
return _CurrentLayers;
}
set
{
_CurrentLayers = value as LayerCfg;
}
}
private void InitTreeNode(IMap pMap)
{
trlProject.Nodes.Clear();
Bitmap groupImg = new Bitmap(Image.FromFile(System.IO.Path.Combine(Application.StartupPath, "images", "grouplayer" + ".png")), 22, 16);
_CurrentLayers = new LayerCfg
{
LayerName = pMap.Name,
SymbolImg = groupImg,
Visible = true,
Data = pMap,
LayerType = EnumLayerType.Map,
Expanded = true
};
for (int i = 0; i < pMap.LayerCount; i++)
{
ILayer layer = pMap.Layer[i];
EnumLayerType layerType = EnumLayerType.GroupLayer;
bool isSeleable = false;
string FcPath = string.Empty;
string FcName = string.Empty;
if (layer is IGroupLayer)
{
FcName = (layer as ILayerGeneralProperties).LayerDescription;
}
if (layer is IFeatureLayer)
{
isSeleable = (layer as IFeatureLayer).Selectable;
layerType = EnumLayerType.FeatureLayer;
FcPath = ((layer as IFeatureLayer).FeatureClass as FeatureClass).Workspace.PathName;
FcName = ((layer as IFeatureLayer).FeatureClass as FeatureClass).BrowseName;
}
LayerCfg subLayerInfo = new LayerCfg(_CurrentLayers)
{
LayerName = layer.Name,
Visible = layer.Visible,
SymbolImg = groupImg,
Selectable = isSeleable,
LayerType = layerType,
FcPath = FcPath,
FcName = FcName,
Data = layer,
Expanded = Layers.FirstOrDefault(x => x.LayerName == layer.Name) != null ? Layers.FirstOrDefault(x => x.LayerName == layer.Name).Expanded : false
};
_CurrentLayers.Layers.Add(subLayerInfo);
CreateNodeByLayer(subLayerInfo);
}
Layers = _CurrentLayers.GetAllItem();
trlProject.ParentFieldName = "PID";
trlProject.KeyFieldName = "ID";
trlProject.CheckBoxFieldName = "Visible";
trlProject.ImageIndexFieldName = "ImgIndex";
trlProject.DataSource = Layers;
RefreshLayerNode();
}
public UCLayerTree(IBundleContext pContext, IMap pMap) : this()
{
//InitTreeNode(pMap);
InitService(pContext);
//axTOCControl1.OnDoubleClick += AxTOCControl1_OnDoubleClick;
//axTOCControl1.OnMouseUp += _axTocCtrl_OnMouseUp;
}
private void InitService(IBundleContext context)
{
context.AddService<IDataCatalogService>(this);
}
private void CreateNodeByLayer(LayerCfg pLayerInfo)
{
try
{
//List<TreeListNode> nodes = trlProject.GetNodeList();
//TreeListNode pNode = nodes.FirstOrDefault(f => f.Tag == pLayer);
//trlProject.FindNodeByFieldValue("NodeName", "");
ILayer mLayer = pLayerInfo.Data as ILayer;
if (mLayer == null)
return;
if (mLayer is ICompositeLayer)
{
Bitmap groupImg = new Bitmap(Image.FromFile(System.IO.Path.Combine(Application.StartupPath, "images", "grouplayer" + ".png")), 22, 16);
for (int i = 0; i < (mLayer as ICompositeLayer).Count; i++)
{
ILayer tempLayer = (mLayer as ICompositeLayer).Layer[i];
if (tempLayer is ICompositeLayer)
{
pLayerInfo.Layers.Add(new LayerCfg(pLayerInfo)
{
LayerName = tempLayer.Name,
Visible = tempLayer.Visible,
SymbolImg = groupImg,
Selectable = Layers.FirstOrDefault(x => x.LayerName == tempLayer.Name) != null ? Layers.FirstOrDefault(x => x.LayerName == tempLayer.Name).Selectable : true,
LayerType = EnumLayerType.GroupLayer,
Data = tempLayer
});
CreateNodeByLayer(pLayerInfo.Layers[pLayerInfo.Layers.Count - 1]);
}
else
{
ILayerEffects mLayerEffects = tempLayer as ILayerEffects;
int Tran = 0;
if (mLayerEffects != null)
Tran = mLayerEffects.Transparency;
Bitmap symbol = new Bitmap(22, 16);
IGeoFeatureLayer fcLayer = tempLayer as IGeoFeatureLayer;
if (fcLayer != null)
{
ISimpleRenderer render = fcLayer.Renderer as ISimpleRenderer;
IUniqueValueRenderer un = null;
if (render == null)
{
un = fcLayer.Renderer as IUniqueValueRenderer;
}
else if (render.Symbol != null)
{
symbol = PreViewFillSymbol(render.Symbol, 22, 16);
}
}
byte[] bytes = null;
if (symbol == null)
{
symbol = new Bitmap(22, 16);
}
MemoryStream ms = new MemoryStream();
symbol.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);
bytes = ms.GetBuffer();
ms.Close();
EnumLayerType layerType = EnumLayerType.FeatureLayer;
string FcPath = string.Empty;
string FcName = string.Empty;
if (tempLayer is IFeatureLayer)
{
FcPath = ((tempLayer as IFeatureLayer).FeatureClass as FeatureClass).Workspace.PathName;
FcName = ((tempLayer as IFeatureLayer).FeatureClass as FeatureClass).BrowseName;
}
else if (tempLayer is IRasterLayer)
{
layerType = EnumLayerType.RasterLayer;
FcPath = (tempLayer as IRasterLayer).FilePath;
}
else if (tempLayer is KOTilesLayer)
{
layerType = EnumLayerType.KOTilesLayer;
FcPath = (tempLayer as KOTilesLayer).DBPath;
}
pLayerInfo.Layers.Add(new LayerCfg(pLayerInfo)
{
LayerName = tempLayer.Name,
Visible = tempLayer.Visible,
SymbolImg = symbol,
Selectable = Layers.FirstOrDefault(x => x.LayerName == tempLayer.Name) != null ? Layers.FirstOrDefault(x => x.LayerName == tempLayer.Name).Selectable : true,
Transparency = Tran,
FcPath = FcPath,
FcName = FcName,
Data = tempLayer,
LayerType = layerType
});
}
}
}
else
{
ILayerEffects mLayerEffects = mLayer as ILayerEffects;
int Tran = 0;
if (mLayerEffects != null)
Tran = mLayerEffects.Transparency;
//ID++;
Bitmap symbol = new Bitmap(22, 16);
IGeoFeatureLayer fcLayer = mLayer as IGeoFeatureLayer;
if (fcLayer != null)
{
ISimpleRenderer render = fcLayer.Renderer as ISimpleRenderer;
IUniqueValueRenderer un = null;
if (render == null)
{
un = fcLayer.Renderer as IUniqueValueRenderer;
}
else
{
symbol = PreViewFillSymbol(render.Symbol, 22, 16);
}
}
byte[] bytes = null;
if (symbol == null)
{
symbol = new Bitmap(22, 16);
}
MemoryStream ms = new MemoryStream();
symbol.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);
bytes = ms.GetBuffer();
ms.Close();
EnumLayerType layerType = EnumLayerType.FeatureLayer;
string FcPath = string.Empty;
string FcName = string.Empty;
if (mLayer is IFeatureLayer)
{
FcPath = ((mLayer as IFeatureLayer).FeatureClass as FeatureClass).Workspace.PathName;
FcName = ((mLayer as IFeatureLayer).FeatureClass as FeatureClass).BrowseName;
}
else if (mLayer is IRasterLayer)
{
layerType = EnumLayerType.RasterLayer;
FcPath = (mLayer as IRasterLayer).FilePath;
}
else if (mLayer is KOTilesLayer)
{
layerType = EnumLayerType.KOTilesLayer;
FcPath = (mLayer as KOTilesLayer).DBPath;
}
pLayerInfo.Layers.Add(new LayerCfg(pLayerInfo)
{
LayerName = mLayer.Name,
Visible = mLayer.Visible,
SymbolImg = symbol,
Selectable = Layers.FirstOrDefault(x => x.LayerName == mLayer.Name) != null ? Layers.FirstOrDefault(x => x.LayerName == mLayer.Name).Selectable : true,
Transparency = Tran,
LayerType = layerType,
FcPath = FcPath,
FcName = FcName,
Data = mLayer
});
}
}
catch (Exception ex)
{
throw ex;
}
}
private Bitmap PreViewFillSymbol(ISymbol pSymbol, int width, int height)
{
try
{
IStyleGalleryClass pStyleGalleryClass = new FillSymbolStyleGalleryClass();
if (pSymbol is ILineSymbol)
{
pStyleGalleryClass = new LineSymbolStyleGalleryClass();
}
else if (pSymbol is IMarkerSymbol)
{
pStyleGalleryClass = new MarkerSymbolStyleGalleryClass();
}
Bitmap img = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
Graphics gc = Graphics.FromImage(img);
//SystemColors.Window
IntPtr hdc = gc.GetHdc();
tagRECT rect = new tagRECT();
rect.left = 0;
rect.top = 0;
rect.right = width;
rect.bottom = height;
pStyleGalleryClass.Preview(pSymbol, hdc.ToInt32(), ref rect);
//gc.Save();
gc.ReleaseHdc(hdc);
gc.Dispose();
img.MakeTransparent(System.Drawing.Color.FromArgb(System.Drawing.SystemColors.Window.ToArgb()));
//System.IO.FileStream s = File.Open(AppDomain.CurrentDomain.BaseDirectory + "Images\\" + pImgName + ".png",FileMode.Open);
//s.Close();
//File.Delete(AppDomain.CurrentDomain.BaseDirectory + "Images\\" + pImgName + ".png");
//img.Save(AppDomain.CurrentDomain.BaseDirectory + "Images\\" + pImgName + ".png");
return img.Clone(new System.Drawing.Rectangle(0, 0, width, height), System.Drawing.Imaging.PixelFormat.Format32bppArgb);
//return img.Clone(new System.Drawing.Rectangle(4, 4, width - 6, height - 6), System.Drawing.Imaging.PixelFormat.Format32bppArgb);
}
catch (Exception ex)
{
LogAPI.Debug(ex.Message);
return null;
}
}
#region IDockPanel接口属性
public Guid ID { get; set; }
public KGIS.Framework.Views.DockStyle DockAreas { get; set; }
public Size FloatSize { get; set; }
public int DockWidth { get; set; }
public int DockHeight { get; set; }
public KGIS.Framework.Views.DockStyle DefaultArea { get; set; }
public bool ShowCloseButton { get; set; }
public bool ShowAutoHideButton { get; set; }
public string Title { get; set; }
#endregion
#region IDataCatalogService 接口
/// <summary>
/// 返回指定图层对应的节点
/// </summary>
/// <param name="layer">图层对象</param>
/// <returns>图层节点</returns>
public object GetNodeByLayer(ILayer layer)
{
if (null == layer) return null;
List<TreeListNode> nodes = trlProject.GetNodeList();
TreeListNode layerNode = null;
foreach (TreeListNode node in nodes)
{
if (node["Data"] == layer)
{
layerNode = node;
break;
}
}
nodes.Clear();
return layerNode;
}
/// <summary>
/// 返回父节点下与指定图层对应的节点
/// </summary>
/// <param name="parentNode">父节点</param>
/// <param name="layer">图层对象</param>
/// <returns>图层节点</returns>
public object GetNodeByLayer(object parentNode, ILayer layer)
{
if (null == layer) return null;
TreeListNodes nodes = null;
if (parentNode is TreeListNode)
{
nodes = (parentNode as TreeListNode).Nodes;
}
else
{
nodes = trlProject.Nodes;
}
foreach (TreeListNode node in nodes)
{
if (node["Data"] == layer) return node;
}
return null;
}
/// <summary>
/// 返回工程树中指定图层名称的节点
/// </summary>
/// <param name="layerName">图层名称</param>
/// <returns>节点</returns>
public object GetNodeByLayerName(string layerName)
{
if (string.IsNullOrEmpty(layerName)) return null;
List<TreeListNode> nodes = trlProject.GetNodeList();
TreeListNode featureNode = null;
foreach (TreeListNode node in nodes)
{
//var ln = node["LayerName"];
if (layerName.Equals(node["LayerName"] as string, StringComparison.OrdinalIgnoreCase))
{
featureNode = node;
break;
}
}
nodes.Clear();
return featureNode;
}
/// <summary>
/// 返回工程树中可选择图层节点的集合
/// </summary>
/// <returns>节点集合</returns>
public object GetSelectableLayerNodes()
{
List<TreeListNode> selectableNodes = new List<TreeListNode>();
//TreeListColumn column1 = trlProject.Columns.ColumnByName("LayerType");
//TreeListColumn column2 = trlProject.Columns.ColumnByName("LayerSelectable");
List<TreeListNode> nodes = trlProject.GetNodeList();
object obj = null;
foreach (TreeListNode node in nodes)
{
//obj = trlProject.GetRowCellValue(node, column1);
obj = node["LayerType"];
if (null == obj) continue;
obj = node["Selectable"]; //trlProject.GetRowCellValue(node, column2);
if (null == obj || !(bool)obj) continue;
selectableNodes.Add(node);
}
nodes.Clear();
return selectableNodes;
}
public object GetVisibleLayerNodes(object parentNode = null)
{
List<TreeListNode> selectableNodes = new List<TreeListNode>();
//TreeListColumn column1 = trlProject.Columns.ColumnByName("LayerType");
//TreeListColumn column2 = trlProject.Columns.ColumnByName("LayerSelectable");
TreeListNodes nodes = trlProject.Nodes;//.GetNodeList();
if (parentNode is TreeListNode)
{
nodes = (parentNode as TreeListNode).Nodes;
}
object obj = null;
foreach (TreeListNode node in nodes)
{
//obj = trlProject.GetRowCellValue(node, column1);
obj = node["LayerType"];
if (null == obj) continue;
obj = node["Visible"]; //trlProject.GetRowCellValue(node, column2);
if (null == obj || !(bool)obj) continue;
selectableNodes.Add(node);
}
nodes.Clear();
return selectableNodes;
}
/// <summary>
/// 返回工程树中选择节点的集合
/// </summary>
/// <param name="orderByIndex">是否按节点索引排序</param>
/// <returns>节点集合</returns>
public object GetSelectedNodes(bool orderByIndex)
{
List<TreeListNode> nodes = new List<TreeListNode>();
for (int i = 0; i < trlProject.Selection.Count; i++)
{
nodes.Add(trlProject.Selection[i]);
}
if (orderByIndex)
{
nodes.Sort(delegate (TreeListNode a, TreeListNode b)
{
if (a.ParentNode == b.ParentNode)
{
if (null == a.ParentNode)
{
return trlProject.Nodes.IndexOf(a).CompareTo(trlProject.Nodes.IndexOf(b));
}
else
{
return a.ParentNode.Nodes.IndexOf(a).CompareTo(b.ParentNode.Nodes.IndexOf(b));
}
}
else
{
return a.Id.CompareTo(b.Id);
}
});
}
return nodes;
}
public object AddLayer(ILayer pLayer, object parentNode = null)
{
LayerCfg layer = null;
if (parentNode is TreeListNode)
{
TreeListNode ParentNode = parentNode as TreeListNode;
LayerCfg ParentLayer = Layers.FirstOrDefault(f => f.LayerName == ParentNode["LayerName"].ToTrim());
if (ParentLayer != null)
{
if (ParentLayer.Data is IGroupLayer)
{
(ParentLayer.Data as IGroupLayer).Add(pLayer);
}
layer = new LayerCfg(ParentLayer);
ParentLayer.Layers.Insert(0, layer);
}
}
else if (parentNode is LayerCfg)
{
LayerCfg ParentLayer = parentNode as LayerCfg;
if (ParentLayer != null)
{
if (ParentLayer.Data is IGroupLayer)
{
(ParentLayer.Data as IGroupLayer).Add(pLayer);
}
layer = new LayerCfg(ParentLayer);
ParentLayer.Layers.Insert(0, layer);
}
}
else
{
if (_CurrentLayers == null)
_CurrentLayers = new LayerCfg();
layer = new LayerCfg(_CurrentLayers);
_CurrentLayers.Layers.Insert(0, layer);
MapsManager.Instance.MapService.getAxMapControl().Map.AddLayer(pLayer);
}
#region 图层名称
layer.LayerName = pLayer.Name;
#endregion
#region 图层是否显示
layer.Visible = pLayer.Visible;
#endregion
#region 图层透明度
if (pLayer is ILayerEffects mLayerEffects)
layer.Transparency = mLayerEffects.Transparency;
#endregion
#region 图层显示比例尺
layer.MinScale = pLayer.MinimumScale.ToInt();
layer.MaxScale = pLayer.MaximumScale.ToInt();
#endregion
layer.Data = pLayer;
if (pLayer is IFeatureLayer mFcLayer)
{
#region 图层要素是否可选择
layer.Selectable = mFcLayer.Selectable;
#endregion
#region 图层显示过滤条件
IFeatureLayerDefinition pFLDefinition = pLayer as IFeatureLayerDefinition;
if (pFLDefinition != null)
{
layer.DefinitionExpression = pFLDefinition.DefinitionExpression;
//Marshal.ReleaseComObject(pFLDefinition);
}
#endregion
#region 图层样式
Renderer randerer = SymbolConvert.Instance().GetRenderer((pLayer as IGeoFeatureLayer).Renderer);
LabelingInfo labelingInfo = null;
LabelStyleConvert styleConvert = new LabelStyleConvert();
List<LabelingInfo> labelInfo = styleConvert.EsriLabelToCustomLabels((pLayer as IGeoFeatureLayer).AnnotationProperties);
if (labelInfo != null && labelInfo.Count > 0)
labelingInfo = labelInfo[0];
if (labelingInfo != null)
{
AdvancedDrawingInfo adi = new AdvancedDrawingInfo();
adi.DrawingInfo.Renderer = randerer;
adi.DrawingInfo.LabelingInfo = labelInfo;
layer.Symbol = adi.ToJson();
}
//LayerCfg layerCfg = _listCfg.FirstOrDefault(f => f.LayerName == pLayer.Name);
//if (layerCfg != null)
//{
// layer.Symbol = layerCfg.Symbol;
// IFeatureRenderer render = GetSymbol(layerCfg.Symbol);
// if (render != null)
// (pLayer as IGeoFeatureLayer).Renderer = render;
//}
Bitmap symbol = new Bitmap(22, 16);
IGeoFeatureLayer fcLayer = pLayer as IGeoFeatureLayer;
if (fcLayer != null)
{
ISimpleRenderer render = fcLayer.Renderer as ISimpleRenderer;
IUniqueValueRenderer un = null;
if (render == null)
{
un = fcLayer.Renderer as IUniqueValueRenderer;
Bitmap groupImg = new Bitmap(Image.FromFile(System.IO.Path.Combine(Application.StartupPath, "images", "DjtbLayer" + ".png")), 22, 16);
symbol = groupImg;//图层多级图层显示
}
else if (render.Symbol != null)
{
symbol = PreViewFillSymbol(render.Symbol, 22, 16);
}
}
byte[] bytes = null;
if (symbol == null)
{
symbol = new Bitmap(22, 16);
}
layer.SymbolImg = symbol;
#endregion
layer.LayerType = EnumLayerType.FeatureLayer;
if ((pLayer as IFeatureLayer).FeatureClass != null)
layer.FcPath = ((pLayer as IFeatureLayer).FeatureClass as FeatureClass).Workspace.PathName;
if ((pLayer as IFeatureLayer).FeatureClass != null)
layer.FcName = ((pLayer as IFeatureLayer).FeatureClass as FeatureClass).BrowseName;
}
else if (pLayer is IRasterLayer)
{
layer.LayerType = EnumLayerType.RasterLayer;
layer.FcPath = (pLayer as IRasterLayer).FilePath;
}
else if (pLayer is WMTSLayer)
{
layer.LayerType = EnumLayerType.WMTSLayer;
layer.FcPath = UserLoginHelper.GetYXGroupLayerValueByAliasName(layer.LayerName) == "" ? UserLoginHelper.GetAppsetingValueByKey("JSYXUrl") : UserLoginHelper.GetYXGroupLayerValueByAliasName(layer.LayerName);
layer.FcName = pLayer.Name;
}
else if (pLayer is KOTilesLayer)
{
layer.LayerType = EnumLayerType.KOTilesLayer;
layer.FcPath = (pLayer as KOTilesLayer).DBPath;
layer.FcName = pLayer.Name;
}
else if (pLayer is IGroupLayer)
{
Bitmap groupImg = new Bitmap(Image.FromFile(System.IO.Path.Combine(Application.StartupPath, "images", "grouplayer" + ".png")), 22, 16);
layer.LayerType = EnumLayerType.GroupLayer;
layer.SymbolImg = groupImg;
ILayerGeneralProperties layerGeneralProperties = pLayer as ILayerGeneralProperties;
if (string.IsNullOrWhiteSpace(layer.FcName))
layer.FcName = layerGeneralProperties.LayerDescription;
}
return layer;
}
public object UpdateLayer(object pData)
{
if (pData is ILayer pLayer)
{
LayerCfg layer = Layers.FirstOrDefault(f => f.Data == pLayer); ;
if (layer == null) return pData;
#region 图层名称
layer.LayerName = pLayer.Name;
#endregion
#region 图层是否显示
layer.Visible = pLayer.Visible;
#endregion
#region 图层透明度
if (pLayer is ILayerEffects mLayerEffects)
layer.Transparency = mLayerEffects.Transparency;
#endregion
#region 图层显示比例尺
layer.MinScale = pLayer.MinimumScale.ToInt();
layer.MaxScale = pLayer.MaximumScale.ToInt();
#endregion
layer.Data = pLayer;
if (pLayer is IFeatureLayer mFcLayer)
{
#region 图层要素是否可选择
layer.Selectable = mFcLayer.Selectable;
#endregion
#region 图层显示过滤条件
IFeatureLayerDefinition pFLDefinition = pLayer as IFeatureLayerDefinition;
if (pFLDefinition != null)
{
layer.DefinitionExpression = pFLDefinition.DefinitionExpression;
//Marshal.ReleaseComObject(pFLDefinition);
}
#endregion
#region 图层样式
Renderer randerer = SymbolConvert.Instance().GetRenderer((pLayer as IGeoFeatureLayer).Renderer);
LabelingInfo labelingInfo = null;
LabelStyleConvert styleConvert = new LabelStyleConvert();
List<LabelingInfo> labelInfo = styleConvert.EsriLabelToCustomLabels((pLayer as IGeoFeatureLayer).AnnotationProperties);
if (labelInfo != null && labelInfo.Count > 0)
labelingInfo = labelInfo[0];
if (labelingInfo != null)
{
AdvancedDrawingInfo adi = new AdvancedDrawingInfo();
adi.DrawingInfo.Renderer = randerer;
adi.DrawingInfo.LabelingInfo = labelInfo;
layer.Symbol = adi.ToJson();
}
//LayerCfg layerCfg = _listCfg.FirstOrDefault(f => f.LayerName == pLayer.Name);
//if (layerCfg != null)
//{
// layer.Symbol = layerCfg.Symbol;
// IFeatureRenderer render = GetSymbol(layerCfg.Symbol);
// if (render != null)
// (pLayer as IGeoFeatureLayer).Renderer = render;
//}
Bitmap symbol = new Bitmap(22, 16);
IGeoFeatureLayer fcLayer = pLayer as IGeoFeatureLayer;
if (fcLayer != null)
{
ISimpleRenderer render = fcLayer.Renderer as ISimpleRenderer;
IUniqueValueRenderer un = null;
if (render == null)
{
un = fcLayer.Renderer as IUniqueValueRenderer;
Bitmap groupImg = new Bitmap(Image.FromFile(System.IO.Path.Combine(Application.StartupPath, "images", "DjtbLayer" + ".png")), 22, 16);
symbol = groupImg;//图层多级图层显示
}
else if (render.Symbol != null)
{
symbol = PreViewFillSymbol(render.Symbol, 22, 16);
}
}
byte[] bytes = null;
if (symbol == null)
{
symbol = new Bitmap(22, 16);
}
layer.SymbolImg = symbol;
#endregion
layer.LayerType = EnumLayerType.FeatureLayer;
layer.FcPath = ((pLayer as IFeatureLayer).FeatureClass as FeatureClass).Workspace.PathName;
layer.FcName = ((pLayer as IFeatureLayer).FeatureClass as FeatureClass).BrowseName;
}
else if (pLayer is IRasterLayer)
{
layer.LayerType = EnumLayerType.RasterLayer;
layer.FcPath = (pLayer as IRasterLayer).FilePath;
}
else if (pLayer is KOTilesLayer)
{
layer.LayerType = EnumLayerType.KOTilesLayer;
layer.FcPath = (pLayer as KOTilesLayer).DBPath;
layer.FcName = pLayer.Name;
}
else if (pLayer is IGroupLayer)
{
Bitmap groupImg = new Bitmap(Image.FromFile(System.IO.Path.Combine(Application.StartupPath, "images", "grouplayer" + ".png")), 22, 16);
layer.LayerType = EnumLayerType.GroupLayer;
layer.SymbolImg = groupImg;
ILayerGeneralProperties layerGeneralProperties = pLayer as ILayerGeneralProperties;
if (string.IsNullOrWhiteSpace(layer.FcName))
layer.FcName = layerGeneralProperties.LayerDescription;
}
return layer;
}
else if (pData is TreeListNode)
{
return pData;
}
return pData;
}
public void RemoveLayer(ILayer pLayer)
{
if (pLayer == null || Layers == null) return;
LayerCfg layerInfo2 = Layers.FirstOrDefault(f => f.Data == pLayer);
if (layerInfo2 == null) return;
LayerCfg infoTemp = Layers.FirstOrDefault(x => x.ID == layerInfo2.PID);
if (infoTemp != null)
infoTemp.Layers.Remove(layerInfo2);
}
public void UpdateTree()
{
if (CurrentLayers == null) return;
Layers = (CurrentLayers as LayerCfg).GetAllItem();
trlProject.ParentFieldName = "PID";
trlProject.KeyFieldName = "ID";
trlProject.CheckBoxFieldName = "Visible";
trlProject.ImageIndexFieldName = "ImgIndex";
trlProject.DataSource = Layers;
MapsManager.Instance.MapService.getAxMapControl().ActiveView.ContentsChanged();
MapsManager.Instance.MapService.getAxMapControl().Refresh();
RefreshLayerNode();
}
/// <summary>
/// 刷新节点历史展开
/// </summary>
private void RefreshLayerNode()
{
foreach (LayerCfg item in Layers.FindAll(x => x.LayerType == EnumLayerType.GroupLayer))
{
if (GetNodeByLayerName(item.LayerName) is TreeListNode rfNode)
{
rfNode.Expanded = item.Expanded;
}
}
}
#endregion
private IFeatureRenderer GetSymbol(string pStrSymbol)
{
IFeatureRenderer result = null;
if (!string.IsNullOrWhiteSpace(pStrSymbol))
{
AdvancedDrawingInfo ad = AdvancedDrawingInfo.FromJson(pStrSymbol);
if (ad != null)
{
if (ad.DrawingInfo.Renderer is Framework.LayerStyleConvert.XSDClass.SimpleRenderer)
{
Symbol symbol1 = (ad.DrawingInfo.Renderer as Framework.LayerStyleConvert.XSDClass.SimpleRenderer).Symbol;
ISimpleRenderer simpleRander2 = SymbolConvert.Instance().GetSimpleRenderer(symbol1, SymbolTypeEnum.Fill);
result = simpleRander2 as IFeatureRenderer;
}
else if (ad.DrawingInfo.Renderer is Framework.LayerStyleConvert.XSDClass.UniqueValueRenderer)
{
Renderer rander = ad.DrawingInfo.Renderer;
IUniqueValueRenderer uniqueValueRander = SymbolConvert.Instance().GetUniqueValueRenderer(rander, SymbolTypeEnum.Fill);
result = uniqueValueRander as IFeatureRenderer;
}
}
}
return result;
}
#region 类事件方法
/// <summary>
/// 工程树节点拖动前事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void trlProject_BeforeDragNode(object sender, DevExpress.XtraTreeList.BeforeDragNodeEventArgs e)
{
if (e.Node.Level == 0 || e.Node["Data"] == null) e.CanDrag = false;
}
/// <summary>
/// 工程树拖放节点经过事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void trlProject_DragOver(object sender, DragEventArgs e)
{
//目标节点
System.Drawing.Point point = trlProject.PointToClient(new System.Drawing.Point(e.X, e.Y));
TreeListNode targetNode = trlProject.CalcHitInfo(point).Node;
//禁止拖放到根节点
if (trlProject.IsRootNode(targetNode))
{
e.Effect = DragDropEffects.None;
}
}
/// <summary>
/// 工程树节点放置后事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void trlProject_DragDrop(object sender, DragEventArgs e)
{
TreeList treeList = sender as TreeList;
//最上部的拖动节点
List<TreeListNode> selectedNodes = GetSelectedNodes(true) as List<TreeListNode>;
if (null == selectedNodes || selectedNodes.Count == 0) return;
//最上部的拖动图层
TreeListNode dragNode = selectedNodes[0];
ILayer sourceLayer = dragNode["Data"] as ILayer;
if (null == sourceLayer) return;
//拖动图层的父节点和父图层
TreeListNode sourceParentNode = null;
ILayer sourceParentLayer = null;
if (null != dragNode.ParentNode)
{
sourceParentNode = dragNode.ParentNode;
sourceParentLayer = sourceParentNode["Data"] as ILayer;
}
//放置节点
DXDragEventArgs args = e.GetDXDragEventArgs(treeList);
TreeListNode dropNode = args.TargetNode;
if (null == dropNode) return;
//放置图层
ILayer targetLayer = dropNode["Data"] as ILayer;
if (null == targetLayer) return;
//放置位置
DragInsertPosition insertPosition = args.DragInsertPosition;
bool dropAsChilds = insertPosition == DragInsertPosition.AsChild;
if (dropAsChilds && !(targetLayer is ICompositeLayer))
{
dropAsChilds = false;
}
//放置节点的父节点和父图层
TreeListNode targetParentNode = null;
ILayer targetParentLayer = null;
if (dropAsChilds)
{
targetParentNode = dropNode;
targetParentLayer = dropNode["Data"] as ILayer;
}
else if (null != dropNode.ParentNode)
{
targetParentNode = dropNode.ParentNode;
targetParentLayer = targetParentNode["Data"] as ILayer;
}
int dragIndex, dropIndex, targetIndex;
List<ILayer> movedLayers = new List<ILayer>();
//拖动节点
treeList.BeginUpdate();
for (int i = 0; i < selectedNodes.Count; i++)
{
dragNode = selectedNodes[i];
sourceLayer = dragNode["Data"] as ILayer;
if (dropAsChilds)
{
targetIndex = dropNode.Nodes.Count;
}
else if (sourceParentNode != targetParentNode)
{
if (insertPosition == DragInsertPosition.After ||
insertPosition == DragInsertPosition.AsChild)
{
targetIndex = GetNodeIndex(dropNode) + i + 1;
}
else
{
targetIndex = GetNodeIndex(dropNode);
}
}
else
{
dragIndex = GetNodeIndex(dragNode);
dropIndex = GetNodeIndex(dropNode);
if (insertPosition == DragInsertPosition.After ||
insertPosition == DragInsertPosition.AsChild)
{
targetIndex = dragIndex < dropIndex ? dropIndex + i : dropIndex + i + 1;
}
else
{
targetIndex = dragIndex < dropIndex ? dropIndex - 1 : dropIndex;
}
}
treeList.MoveNode(dragNode, targetParentNode, true, targetIndex);
movedLayers.Add(sourceLayer);
}
//更新节点可见性
TreeListColumn column = treeList.Columns.ColumnByName("LayerVisible");
if (sourceParentNode != targetParentNode)
{
UpdateParentVisible(selectedNodes[0]);
if (null != sourceParentNode)
{
if (sourceParentNode.HasChildren)
{
UpdateParentVisible(sourceParentNode.Nodes[0]);
}
else if (treeList.GetRowCellValue(sourceParentNode, column) == null)
{
treeList.SetRowCellValue(sourceParentNode, column, false);
}
}
}
treeList.EndUpdate();
targetIndex = GetNodeIndex(selectedNodes[0]);
ReorderLayers(sourceParentLayer, targetParentLayer, movedLayers, targetIndex);
selectedNodes.Clear();
movedLayers.Clear();
e.Effect = DragDropEffects.None;
//CurrentLayers = treeList.DataSource;
//Layers = treeList.DataSource as List<LayerCfg>;
UpdateTree();
}
/// <summary>
/// 工程树获取节点状态图片事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void trlProject_GetStateImage(object sender, DevExpress.XtraTreeList.GetStateImageEventArgs e)
{
int imageIndex = this.GetNodeStateImageIndex(e.Node);
if (imageIndex != -1)
{
e.NodeImageIndex = imageIndex;
}
}
/// <summary>
/// 工程树鼠标弹起事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void trlProject_MouseUp(object sender, MouseEventArgs e)
{
TreeList treeList = sender as TreeList;
if (e.Button != MouseButtons.Right) return;
System.Drawing.Point point = new System.Drawing.Point(e.X, e.Y);
TreeListNode focusedNode = treeList.CalcHitInfo(point).Node;
if (null == focusedNode)
{
treeList.Selection.Clear();
return;
}
if (!treeList.Selection.Contains(focusedNode))
{
try
{
treeList.Selection.Set(focusedNode);
}
catch (Exception ex)
{
LogAPI.Debug(ex);
return;
}
}
ILayer layer = focusedNode["Data"] as ILayer;
bool isSingleNodeSelected = treeList.Selection.Count == 1;
if (layer == null)
{
MapsManager.Instance.MapService.SetCustomProperty(MapsManager.Instance.MapService.getAxMapControl().Map);
SetMenuEnabled(popMapMenu);
popMapMenu.ShowPopup(Control.MousePosition);//弹出右键菜单
}
else
{
MapsManager.Instance.MapService.SetCustomProperty(layer);
if (layer is IGroupLayer)
{
////图层组
SetMenuEnabled(popGroupMenu);
popGroupMenu.ShowPopup(Control.MousePosition);//弹出右键菜单
}
else
{
SetMenuEnabled(popLayerMenu);
popLayerMenu.ShowPopup(Control.MousePosition);//弹出右键菜单
}
}
}
/// <summary>
/// 设置弹出菜单最新状态
/// </summary>
/// <param name="menu"></param>
public void SetMenuEnabled(PopupMenu menu)
{
foreach (LinkPersistInfo menuitem in menu.LinksPersistInfo)//循环设置右键菜单启用/禁用状态
{
if ((menuitem.Item as BarButtonItem) != null)
{
var tmpmenu = menuitem.Item as BarButtonItem;
var tmpcmd = tmpmenu.Tag;
if (tmpcmd == null) return;
Type type = tmpcmd.GetType(); //获取类型
try
{
var propertyInfo = type.GetProperty("Enabled");//获取最新启用状态
//设置菜单启用禁用
tmpmenu.Enabled = (bool)propertyInfo.GetValue(tmpcmd, null);
propertyInfo = type.GetProperty("Caption");
if (propertyInfo == null) return;
object title = propertyInfo.GetValue(tmpcmd, null);
if (title == null) continue;
if (string.IsNullOrWhiteSpace(title.ToTrim())) continue; ;
tmpmenu.Caption = title.ToTrim();
}
catch (Exception exc)
{
LogAPI.Debug(exc);
}
}
}
}
/// <summary>
/// 工程树选择改变事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void trlProject_SelectionChanged(object sender, EventArgs e)
{
TreeList treeList = sender as TreeList;
if (treeList.Selection.Count > 1)
{
TreeListNode focusedNode = treeList.FocusedNode;
int parentNodeId, nodeId;
if (null != treeList.Selection[0].ParentNode)
{
parentNodeId = treeList.Selection[0].ParentNode.Id;
}
else
{
parentNodeId = -1;
}
for (int i = 1; i < treeList.Selection.Count; i++)
{
if (null != treeList.Selection[i].ParentNode)
{
nodeId = treeList.Selection[i].ParentNode.Id;
}
else
{
nodeId = -1;
}
if (parentNodeId != nodeId)
{
treeList.Selection.Set(focusedNode);
break;
}
}
}
//OnSelectedLayersChanged();
}
private void trlProject_AfterCheckNode(object sender, NodeEventArgs e)
{
//List<LayerCfg> list = (sender as TreeList).DataSource as List<LayerCfg>;
//var layerInfo = list.FirstOrDefault(f => f.ID == e.Node.Id);
//if (layerInfo == null)
//{
if (e.Node.GetValue("Data") is ILayer)
{
ILayer layer = e.Node.GetValue("Data") as ILayer;
layer.Visible = e.Node.Checked;
SaveProjectInfo(layer.Name, e.Node.Checked, out LayerCfg layerInfo);
if (layerInfo != null)
LayerCfgList = layerInfo.GetAllItem();
UpdateLayer(e.Node, e.Node.Checked);
MapsManager.Instance.MapService.getAxMapControl().ActiveView.Refresh();
}
//}
}
private void SaveProjectInfo(string layerName, bool isCheck, out LayerCfg layerInfo)
{
layerInfo = null;
try
{
ProjectInfo ProInfo = MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo;
if (ProInfo != null && !string.IsNullOrWhiteSpace(ProInfo.TempData))
{
byte[] contentArray = Convert.FromBase64String(ProInfo.TempData);
string LayerCfg = System.Text.Encoding.Default.GetString(contentArray);
layerInfo = KGIS.Framework.Utils.SerializeAPI.DeserializeToObject<LayerCfg>(LayerCfg);
}
layerInfo.GetAllItem().Find(a => a.LayerName == layerName).Visible = isCheck;
Byte[] bytearr = System.Text.Encoding.Default.GetBytes(SerializeAPI.SerializeToXML<LayerCfg>(layerInfo));
string strBase64 = Convert.ToBase64String(bytearr);
ProInfo.TempData = strBase64;
ProInfo.Save();
}
catch (Exception ex)
{
return;
}
}
List<LayerCfg> LayerCfgList = new List<LayerCfg>();
private void UpdateLayer(TreeListNode child, bool isCheck)
{
if (child != null && child.Nodes != null)
{
foreach (TreeListNode item in child.Nodes)
{
ILayer layer = item.GetValue("Data") as ILayer;
if (layer == null) continue;
if (!isCheck)
{
layer.Visible = false;
}
else if (!item.Checked)
{
layer.Visible = false;
}
else
{
LayerCfg layerCfg = LayerCfgList.Find(a => a.LayerName == layer.Name);
layer.Visible = layerCfg == null ? layer.Visible : GetParentIsChecked(layerCfg);
}
UpdateLayer(item, isCheck);
}
}
}
private bool GetParentIsChecked(LayerCfg layer)
{
if (LayerCfgList == null || LayerCfgList.Count == 0) return true;
LayerCfg parent = LayerCfgList.Find(a => a.Layers.Contains(layer));
if (parent == null)
{
return true;
}
else if (!parent.Visible)
{
return false;
}
else
{
return GetParentIsChecked(parent);
}
}
private void RepositoryItemSpinEdit1_EditValueChanged(object sender, System.EventArgs e)
{
ILayer layer = trlProject.FocusedNode["Data"] as ILayer;
ILayerEffects mLayerEffects = layer as ILayerEffects;
if (mLayerEffects != null)
{
mLayerEffects.Transparency = ((short)(sender as SpinEdit).EditValue.ToInt());
MapsManager.Instance.MapService.getAxMapControl().ActiveView.Refresh();
}
}
/// <summary>
/// 工程树图层显示/隐藏选择状态改变事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void chkLayerVisible_CheckedChanged(object sender, EventArgs e)
{
if (null == trlProject.FocusedNode) return;
CheckEdit chkVisible = sender as CheckEdit;
ILayer layer = trlProject.FocusedNode["Data"] as ILayer;
trlProject.BeginUnboundLoad();
TreeListColumn column = trlProject.Columns.ColumnByName("LayerVisible");
trlProject.SetRowCellValue(trlProject.FocusedNode, column, chkVisible.Checked);
if (trlProject.FocusedNode.ParentNode != null)
{
UpdateParentVisible(trlProject.FocusedNode);
}
if (trlProject.FocusedNode.HasChildren)
{
UpdateChildVisible(trlProject.FocusedNode);
}
trlProject.EndUnboundLoad();
if (layer != null)
{
layer.Visible = chkVisible.Checked;
}
MapsManager.Instance.MapService.getAxMapControl().ActiveView.Refresh();
//this.ActiveView.Refresh();
//ProjectHelper.MakeDirty();
}
/// <summary>
/// 工程树图层可编辑点击事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void chkLayerEditable_Click(object sender, EventArgs e)
{
if (null == trlProject.FocusedNode) return;
TreeListColumn column = trlProject.Columns.ColumnByName("LayerEditable");
object obj = trlProject.GetRowCellValue(trlProject.FocusedNode, column);
if (obj == null) return;
ILayer layer = trlProject.FocusedNode["Data"] as ILayer;
if (null == layer || !layer.Valid || !(layer is IFeatureLayer)) return;
IFeatureLayer featureLayer = layer as IFeatureLayer;
CheckEdit chkLayerEditable = sender as CheckEdit;
switch (chkLayerEditable.CheckState)
{
case CheckState.Checked:
chkLayerEditable.CheckState = CheckState.Unchecked;
featureLayer.Selectable = false;
trlProject.SetRowCellValue(trlProject.FocusedNode, column, false);
//更新编辑捕捉环境
//this.OnSystemSnapChanged();
break;
case CheckState.Unchecked:
chkLayerEditable.CheckState = CheckState.Checked;
featureLayer.Selectable = true;
trlProject.SetRowCellValue(trlProject.FocusedNode, column, true);
//更新编辑捕捉环境
//this.OnSystemSnapChanged();
break;
}
//ProjectHelper.MakeDirty();
}
private TreeListNode mCurrentEditorNode = null;
private void chkLayerEditable_DoubleClick(object sender, EventArgs e)
{
if (null == trlProject.FocusedNode) return;
//TreeListColumn column = trlProject.Columns.ColumnByName("LayerEditable");
//object obj = trlProject.GetRowCellValue(trlProject.FocusedNode, column);
//if (obj == null) return;
List<TreeListNode> nodes = trlProject.GetNodeList();
TreeListColumn column = trlProject.Columns.ColumnByName("LayerEditable");
ILayer layer = trlProject.FocusedNode["Data"] as ILayer;
if (null == layer || !layer.Valid || !(layer is IFeatureLayer)) return;
IFeatureLayer featureLayer = layer as IFeatureLayer;
if (featureLayer != null)
{
IEngineEditor tEngineEdit = new EngineEditorClass();
IEngineEditLayers pEditLayer = tEngineEdit as IEngineEditLayers;
//if (pEditLayer.IsEditable(featureLayer))
//{
if (tEngineEdit.EditState != esriEngineEditState.esriEngineStateEditing)
{
tEngineEdit.StartEditing((featureLayer.FeatureClass as FeatureClass).Workspace, MapsManager.Instance.MapService.getAxMapControl().Map);
}
pEditLayer.SetTargetLayer(featureLayer, 0);
if (mCurrentEditorNode != null)
{
trlProject.SetRowCellValue(mCurrentEditorNode, column, null);
}
trlProject.FocusedNode.SetValue(column, true);
//trlProject.Columns["NodeName"].AppearanceCell.ForeColor = Color.Red;
mCurrentEditorNode = trlProject.FocusedNode;// trlProject.SetRowCellValue(trlProject.FocusedNode, "", true);
//}
//FormatConditionRuleValue ruleForMark = new FormatConditionRuleValue();
//ruleForMark.Condition = FormatCondition.Expression;
//ruleForMark.Expression = "[IsEditable] == true";
//ruleForMark.Appearance.BackColor = Color.Red;
//trlProject.FormatRules.Add(trlProject.Columns["NodeName"], ruleForMark);
}
//ProjectHelper.MakeDirty();
}
//private void txtLayerName_DoubleClick(object sender, EventArgs e)
//{
// ILayer layer = trlProject.FocusedNode["Data"] as ILayer;
// if (null == layer || !layer.Valid || !(layer is IFeatureLayer)) return;
// IFeatureLayer featureLayer = layer as IFeatureLayer;
// if (featureLayer != null)
// {
// IEngineEditLayers pEditLayer = new EngineEditorClass();
// pEditLayer.SetTargetLayer(featureLayer, 0);
// }
//}
/// <summary>
/// 工程树图层可选择状态改变事件方法
/// </summary>
/// <param name="sender">事件发送者</param>
/// <param name="e">事件参数</param>
private void chkLayerSelectable_CheckedChanged(object sender, EventArgs e)
{
try
{
if (null == trlProject.FocusedNode) return;
CheckEdit chkSelectable = sender as CheckEdit;
ILayer layer = trlProject.FocusedNode.GetValue("Data") as ILayer;
trlProject.BeginUnboundLoad();
TreeListColumn column = trlProject.Columns.ColumnByName("LayerSelectable");
trlProject.SetRowCellValue(trlProject.FocusedNode, column, chkSelectable.Checked);
if (trlProject.FocusedNode.ParentNode != null)
{
UpdateParentSelectable(trlProject.FocusedNode);
}
if (trlProject.FocusedNode.HasChildren)
{
UpdateChildSelectable(trlProject.FocusedNode);
}
if (layer is IFeatureLayer)
{
(layer as IFeatureLayer).Selectable = chkSelectable.Checked;
}
trlProject.EndUnboundLoad();
MapsManager.Instance.MapService.getAxMapControl().ActiveView.Refresh();
//ProjectHelper.MakeDirty();
}
catch (Exception ex)
{
LogAPI.Debug(ex.Message);
}
}
#endregion
/// <summary>
/// 返回指定节点的索引
/// </summary>
/// <param name="node">节点</param>
/// <returns>节点索引</returns>
public int GetNodeIndex(TreeListNode node)
{
if (null == node) return -1;
if (null == node.ParentNode)
{
return trlProject.Nodes.IndexOf(node);
}
else
{
return node.ParentNode.Nodes.IndexOf(node);
}
}
/// <summary>
/// 返回工程树中指定图层编码的节点
/// </summary>
/// <param name="layerId">图层编码</param>
/// <returns>节点</returns>
public TreeListNode GetNodeByLayerId(string layerId)
{
if (string.IsNullOrEmpty(layerId)) return null;
TreeListColumn column = trlProject.Columns.ColumnByName("Id");
List<TreeListNode> nodes = trlProject.GetNodeList();
TreeListNode layerNode = null;
foreach (TreeListNode node in nodes)
{
if (layerId.Equals(trlProject.GetRowCellValue(node, column) as string, StringComparison.OrdinalIgnoreCase))
{
layerNode = node;
break;
}
}
nodes.Clear();
return layerNode;
}
/// <summary>
/// 返回工程树中可编辑图层节点的集合
/// </summary>
/// <returns>节点集合</returns>
public List<TreeListNode> GetEditableLayerNodes()
{
List<TreeListNode> editableNodes = new List<TreeListNode>();
TreeListColumn column1 = trlProject.Columns.ColumnByName("LayerType");
TreeListColumn column2 = trlProject.Columns.ColumnByName("LayerEditable");
List<TreeListNode> nodes = trlProject.GetNodeList();
object obj = null;
foreach (TreeListNode node in nodes)
{
obj = trlProject.GetRowCellValue(node, column1);
if (null == obj || (int)obj != (int)EnumFeatureLayerType.ShapeFileFeatureLayer) continue;
obj = trlProject.GetRowCellValue(node, column2);
if (null != obj && !(bool)obj) continue;
editableNodes.Add(node);
}
nodes.Clear();
return editableNodes;
}
/// <summary>
/// 返回工程树中正在编辑节点的集合
/// </summary>
/// <returns>节点</returns>
public TreeListNode GetEditingLayerNode()
{
TreeListNode editingNode = null;
TreeListColumn column1 = trlProject.Columns.ColumnByName("LayerType");
TreeListColumn column2 = trlProject.Columns.ColumnByName("LayerEditable");
List<TreeListNode> nodes = trlProject.GetNodeList();
object obj = null;
foreach (TreeListNode node in nodes)
{
obj = trlProject.GetRowCellValue(node, column1);
if (null == obj || (int)obj != (int)EnumFeatureLayerType.ShapeFileFeatureLayer) continue;
obj = trlProject.GetRowCellValue(node, column2);
if (null != obj) continue;
editingNode = node;
break;
}
nodes.Clear();
return editingNode;
}
/// <summary>
/// 更新父节点图层显示的选择状态
/// </summary>
/// <param name="node">工程树节点</param>
public void UpdateParentVisible(TreeListNode node)
{
if (null == node || null == node.ParentNode) return;
object obj = null;
int visibleCount = 0, pendingCount = 0;
TreeListColumn column = trlProject.Columns.ColumnByName("LayerVisible");
foreach (TreeListNode n in node.ParentNode.Nodes)
{
obj = trlProject.GetRowCellValue(n, column);
if (null == obj)
{
pendingCount++;
}
else if ((bool)obj)
{
visibleCount++;
}
}
bool visible = false;
if (pendingCount > 0)
{
trlProject.SetRowCellValue(node.ParentNode, column, null);
visible = true;
}
else if (visibleCount == node.ParentNode.Nodes.Count)
{
trlProject.SetRowCellValue(node.ParentNode, column, true);
visible = true;
}
else if (visibleCount == 0)
{
trlProject.SetRowCellValue(node.ParentNode, column, false);
visible = false;
}
else
{
trlProject.SetRowCellValue(node.ParentNode, column, null);
visible = true;
}
ILayer layer = node.ParentNode["Data"] as ILayer;
if (null != layer && layer.Visible != visible)
{
layer.Visible = visible;
}
if (null != node.ParentNode.ParentNode)
{
UpdateParentVisible(node.ParentNode);
}
}
/// <summary>
/// 更新子节点图层显示的选择状态
/// </summary>
/// <param name="node">工程树节点</param>
public void UpdateChildVisible(TreeListNode node)
{
if (null == node || !node.HasChildren) return;
TreeListColumn column = trlProject.Columns.ColumnByName("LayerVisible");
object obj = trlProject.GetRowCellValue(node, column);
if (null == obj) return;
bool visible = (bool)obj;
ILayer layer = null;
foreach (TreeListNode n in node.Nodes)
{
trlProject.SetRowCellValue(n, column, visible);
layer = n["Data"] as ILayer;
if (null != layer && layer.Visible != visible)
{
layer.Visible = visible;
}
if (n.HasChildren)
{
UpdateChildVisible(n);
}
}
}
/// <summary>
/// 更新父节点图层的可选择状态
/// </summary>
/// <param name="node">工程树节点</param>
public void UpdateParentSelectable(TreeListNode node)
{
if (null == node || null == node.ParentNode) return;
object obj = null;
int visibleCount = 0, pendingCount = 0;
TreeListColumn column = trlProject.Columns.ColumnByName("LayerSelectable");
foreach (TreeListNode n in node.ParentNode.Nodes)
{
obj = trlProject.GetRowCellValue(n, column);
if (null == obj)
{
pendingCount++;
}
else if ((bool)obj)
{
visibleCount++;
}
}
if (pendingCount > 0)
{
trlProject.SetRowCellValue(node.ParentNode, column, null);
}
else if (visibleCount == node.ParentNode.Nodes.Count)
{
trlProject.SetRowCellValue(node.ParentNode, column, true);
}
else if (visibleCount == 0)
{
trlProject.SetRowCellValue(node.ParentNode, column, false);
}
else
{
trlProject.SetRowCellValue(node.ParentNode, column, null);
}
if (null != node.ParentNode.ParentNode)
{
this.UpdateParentSelectable(node.ParentNode);
}
}
/// <summary>
/// 更新子节点图层的可选择状态
/// </summary>
/// <param name="node">工程树节点</param>
public void UpdateChildSelectable(TreeListNode node)
{
if (null == node || !node.HasChildren) return;
TreeListColumn column = trlProject.Columns.ColumnByName("LayerSelectable");
object obj = trlProject.GetRowCellValue(node, column);
if (null == obj) return;
bool selectable = (bool)obj;
ILayer layer = null;
foreach (TreeListNode n in node.Nodes)
{
trlProject.SetRowCellValue(n, column, selectable);
layer = n["Data"] as ILayer;
if (layer is IFeatureLayer)
{
(layer as IFeatureLayer).Selectable = selectable;
}
if (n.HasChildren)
{
UpdateChildSelectable(n);
}
}
}
/// <summary>
/// 显示图层节点
/// </summary>
/// <param name="node">图层节点</param>
public void ShowNode(TreeListNode node)
{
if (null == node) return;
this.trlProject.BeginUpdate();
node.Expand();
this.trlProject.Selection.Clear();
this.trlProject.SelectNode(node);
this.trlProject.SetFocusedNode(node);
this.trlProject.MakeNodeVisible(node);
this.trlProject.EndUpdate();
}
/// <summary>
/// 在父节点下移除已删除图层节点
/// </summary>
/// <param name="parentNode">父节点</param>
/// <param name="layers">图层集合</param>
public void OnLayersRemoved(TreeListNode parentNode, List<ILayer> layers)
{
if (null == layers) return;
trlProject.BeginUnboundLoad();
TreeListNode node = null;
foreach (ILayer layer in layers)
{
node = GetNodeByLayer(parentNode, layer) as TreeListNode;
if (null == node) continue;
if (null != node.ParentNode)
{
node.ParentNode.Nodes.Remove(node);
}
else
{
this.trlProject.Nodes.Remove(node);
}
}
//更新图层可见性
TreeListColumn column = this.trlProject.Columns.ColumnByName("LayerVisible");
if (null != parentNode)
{
TreeListNode updateNode = parentNode;
if (parentNode.HasChildren)
{
updateNode = parentNode.Nodes[0];
}
else if (trlProject.GetRowCellValue(updateNode, column) == null)
{
trlProject.SetRowCellValue(updateNode, column, true);
}
UpdateParentVisible(updateNode);
UpdateChildVisible(updateNode);
UpdateParentSelectable(updateNode);
UpdateChildSelectable(updateNode);
}
trlProject.EndUnboundLoad();
//ProjectHelper.MakeDirty();
}
/// <summary>
/// 查找图层在父节点中的位置索引
/// </summary>
/// <param name="map">地图对象</param>
/// <param name="parentNode">图层父节点</param>
/// <param name="layer">图层</param>
/// <returns>位置索引</returns>
private int FindLayerNodeIndex(IMap map, TreeListNode parentNode, ILayer layer)
{
if (null == layer) return -1;
int layerIndex = this.GetLayerIndex(map, layer);
if (layerIndex == -1) return -1;
TreeListNodes childNodes = null;
if (null == parentNode)
{
childNodes = this.trlProject.Nodes;
}
else
{
childNodes = parentNode.Nodes;
}
int k = 0, childLayerIndex = 0, layerNodeIndex = 0;
ILayer childLayer = null;
foreach (TreeListNode childNode in childNodes)
{
k++;
if (!(childNode.Tag is ILayer)) continue;
childLayer = childNode.Tag as ILayer;
childLayerIndex = this.GetLayerIndex(map, childLayer);
if (childLayerIndex == -1) continue;
if (layerIndex > childLayerIndex) layerNodeIndex = k;
}
return layerNodeIndex;
}
public int GetLayerIndex(IMap map, ILayer layer)
{
if (null == map || null == layer) return -1;
for (int i = 0; i < map.LayerCount; i++)
{
if (map.Layer[i] is ICompositeLayer)
{
ICompositeLayer groupLayer = map.Layer[i] as ICompositeLayer;
for (int j = 0; j < groupLayer.Count; j++)
{
if (groupLayer.Layer[j] == layer) return i + j;
}
}
if (map.get_Layer(i) == layer) return i;
}
return -1;
}
/// <summary>
/// 返回节点状态图片的索引
/// </summary>
/// <param name="node">节点</param>
/// <returns>状态图片索引</returns>
private int GetNodeStateImageIndex(TreeListNode node)
{
if (null == node) return -1;
ILayer layer = node.Tag as ILayer;
if (null == layer)
{
return 5;
}
else if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
if (!featureLayer.Valid || null == featureLayer.FeatureClass)
{
return 4;
}
switch (featureLayer.FeatureClass.ShapeType)
{
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint:
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryMultipoint:
return 0;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline:
return 1;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon:
return 2;
}
}
else if (layer is IRasterLayer)
{
return 3;
}
return -1;
}
/// <summary>
/// 调整图层集合中图层的顺序
/// </summary>
/// <param name="sourceParentLayer">源图层的父图层</param>
/// <param name="targetParentLayer">目标图层的父图层</param>
/// <param name="moveLayers">图层集合</param>
/// <param name="dropAsChilds">是否作为子图层</param>
/// <param name="targetIndex">图层的放置索引</param>
/// <param name="direction">图层的放置方向</param>
private void ReorderLayers(ILayer sourceParentLayer, ILayer targetParentLayer, List<ILayer> moveLayers, int targetIndex)
{
if (null == moveLayers || moveLayers.Count == 0) return;
IMap map = MapsManager.Instance.MapService.getAxMapControl().Map;
IMapLayers2 mapLayers = map as IMapLayers2;
IMapAdmin3 mapAdmin = map as IMapAdmin3;
LayerCfg layerInfo = null;
//LayerCfg cfg = null;//Layers.FirstOrDefault(f => f.Data == sourceParentLayer);
//foreach (var item in Layers)
//{
// if (item.Data == sourceParentLayer)
// {
// cfg = item;
// break;
// }
//}
//移除图层
for (int i = 0; i < moveLayers.Count; i++)
{
//LayerCfg MoveLayerCfg = null;//Layers.FirstOrDefault(f => f.Data == sourceParentLayer);
//foreach (var item in Layers)
//{
// if (item.Data == moveLayers[i])
// {
// MoveLayerCfg = item;
// break;
// }
//}
if (null == sourceParentLayer)
{
map.DeleteLayer(moveLayers[i]);
}
else
{
//CurrentLayers
//if (cfg != null)
//{
// if (MoveLayerCfg != null)
// cfg.Layers.Remove(MoveLayerCfg);
//}
(sourceParentLayer as IGroupLayer).Delete(moveLayers[i]);
}
mapAdmin.FireLayerDeleted(moveLayers[i]);
layerInfo = Layers.FirstOrDefault(f => f.LayerName == moveLayers[i].Name);
if (layerInfo != null)
{
LayerCfg parentLayerInfo = Layers.FirstOrDefault(f => f.ID == layerInfo.PID);
parentLayerInfo.Layers.Remove(layerInfo);
}
}
LayerCfg ParentLayInfo = null;
//增加图层
for (int i = 0; i < moveLayers.Count; i++)
{
if (null == targetParentLayer)
{
mapLayers.InsertLayer(moveLayers[i], false, targetIndex + i);
ParentLayInfo = _CurrentLayers;
}
else
{
mapLayers.InsertLayerInGroup(targetParentLayer as IGroupLayer, moveLayers[i], false, targetIndex + i);
ParentLayInfo = Layers.FirstOrDefault(f => f.LayerName == targetParentLayer.Name);
}
if (ParentLayInfo != null)
{
ParentLayInfo.Layers.Insert(targetIndex, layerInfo);
}
mapAdmin.FireLayerAdded(moveLayers[i]);
}
//ProjectHelper.MakeDirty();
//刷新地图
IActiveView activeView = map as IActiveView;
activeView.PartialRefresh(esriViewDrawPhase.esriViewGeography | esriViewDrawPhase.esriViewGeoSelection, null, activeView.Extent);
}
/// <summary>
/// 折叠指定节点的所有子节点
/// </summary>
/// <param name="node">节点</param>
private void CollapseLayerNode(TreeListNode node)
{
if (null == node || !node.HasChildren) return;
foreach (TreeListNode childNode in node.Nodes)
{
CollapseLayerNode(childNode);
}
node.Collapse();
}
/// <summary>
/// 匹配要素样式
/// </summary>
/// <param name="featureLayer">要素图层</param>
/// <param name="fieldName">字段名称</param>
/// <param name="uniqueValues">唯一值集合</param>
/// <param name="uniqueValueRenderer">单一值渲染器</param>
public void MatchFeatureStyle(IFeatureLayer featureLayer, string fieldName, List<object> uniqueValues, IUniqueValueRenderer uniqueValueRenderer)
{
if (null == featureLayer || !featureLayer.Valid || string.IsNullOrEmpty(fieldName) ||
null == uniqueValues || uniqueValues.Count == 0 || null == uniqueValueRenderer) return;
IFeatureClass featureClass = featureLayer.FeatureClass;
ESRI.ArcGIS.Geometry.esriGeometryType geometryType = featureClass.ShapeType;
//设置单值渲染器的属性.
uniqueValueRenderer.FieldCount = 1;
uniqueValueRenderer.set_Field(0, fieldName);
uniqueValueRenderer.DefaultSymbol = GetDefaultFeatureSymbol(geometryType, null);
uniqueValueRenderer.DefaultLabel = null;//Constant.Field_NullValue_Label;
uniqueValueRenderer.UseDefaultSymbol = false;
//设置算术颜色带
bool ok = false;
IAlgorithmicColorRamp randomColorRamp = new AlgorithmicColorRampClass();
randomColorRamp.FromColor = GetColor(100, 100, 60);
randomColorRamp.ToColor = GetColor(0, 100, 100);
randomColorRamp.Size = uniqueValues.Count * 2;
randomColorRamp.CreateRamp(out ok);
IEnumColors enumColors = randomColorRamp.Colors;
enumColors.Reset();
//设置单值渲染器的值和符号
IStyleGalleryItem styleGalleryItem = null;
ISymbol symbol = null;
foreach (string uniqueValue in uniqueValues)
{
switch (geometryType)
{
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint:
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryMultipoint:
styleGalleryItem = this.GetStyleGalleryItem("Marker Symbols", uniqueValue);
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline:
styleGalleryItem = this.GetStyleGalleryItem("Line Symbols", uniqueValue);
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon:
styleGalleryItem = this.GetStyleGalleryItem("Fill Symbols", uniqueValue);
break;
}
if (null != styleGalleryItem)
{
symbol = styleGalleryItem.Item as ISymbol;
}
else
{
symbol = GetDefaultFeatureSymbol(geometryType, enumColors.Next());
}
uniqueValueRenderer.AddValue(uniqueValue, fieldName, symbol);
uniqueValueRenderer.set_Heading(uniqueValue, uniqueValue);
uniqueValueRenderer.set_Label(uniqueValue, uniqueValue);
uniqueValueRenderer.set_Description(uniqueValue, uniqueValue);
uniqueValueRenderer.set_Symbol(uniqueValue, symbol);
}
ITable table = featureLayer as ITable;
int fieldIndex = table.Fields.FindField(fieldName);
bool isStringType = table.Fields.get_Field(fieldIndex).Type == ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeString;
uniqueValueRenderer.set_FieldType(0, isStringType);
uniqueValueRenderer.ColorScheme = "自定义";
if (null != enumColors) DisposeArcGISObject(enumColors);
if (null != randomColorRamp) DisposeArcGISObject(randomColorRamp);
}
private IStyleGalleryItem GetStyleGalleryItem(string styleClassName, string styleName)
{
if (string.IsNullOrEmpty(styleClassName) || string.IsNullOrEmpty(styleName)) return null;
IEnumStyleGalleryItem enumStyleGalleryItem = null;
IStyleGalleryItem styleGalleryItem = null;
try
{
//enumStyleGalleryItem = this.styleGallery.get_Items(styleClassName, ConfigHelper.GetStyleFile(), null);
//enumStyleGalleryItem.Reset();
//while ((styleGalleryItem = enumStyleGalleryItem.Next()) != null)
//{
// if (styleGalleryItem.Name.Equals(styleName, StringComparison.OrdinalIgnoreCase))
// {
// return styleGalleryItem;
// }
//}
return null;
}
catch (Exception ex)
{
Console.WriteLine(String.Format("获取样式类{0}失败：{1}", styleClassName, ex.Message));
return null;
}
finally
{
if (null != enumStyleGalleryItem)
{
DisposeArcGISObject(enumStyleGalleryItem);
}
}
}
public void DisposeArcGISObject(object obj)
{
if (obj == null) return;
int refCount = 1;
while (refCount > 0)
{
refCount = System.Runtime.InteropServices.Marshal.ReleaseComObject(obj);
}
obj = null;
}
public static IColor GetColor(int red, int green, int blue)
{
IRgbColor color = new RgbColor();
color.Red = red;
color.Green = green;
color.Blue = blue;
return color as IColor;
}
public ISymbol GetDefaultFeatureSymbol(ESRI.ArcGIS.Geometry.esriGeometryType shapeType, IColor color)
{
switch (shapeType)
{
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint:
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryMultipoint:
ISimpleMarkerSymbol markerSymbol = new SimpleMarkerSymbolClass();
markerSymbol.Style = ESRI.ArcGIS.Display.esriSimpleMarkerStyle.esriSMSCircle;
markerSymbol.Size = 7;
markerSymbol.Color = color == null ? GetColor(0, 166, 116) : color;
markerSymbol.Outline = true;
markerSymbol.OutlineSize = 1;
markerSymbol.OutlineColor = GetColor(78, 78, 78);
return markerSymbol as ISymbol;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline:
ISimpleLineSymbol lineSymbol = new SimpleLineSymbolClass();
lineSymbol.Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSSolid;
lineSymbol.Color = color == null ? GetColor(230, 152, 0) : color;
lineSymbol.Width = 1;
return lineSymbol as ISymbol;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon:
ISimpleLineSymbol borderSymbol = new SimpleLineSymbol();
borderSymbol.Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSSolid;
borderSymbol.Color = GetColor(110, 110, 110);
borderSymbol.Width = 0.4;
ISimpleFillSymbol simpleFillSymbol = new SimpleFillSymbolClass();
simpleFillSymbol.Style = ESRI.ArcGIS.Display.esriSimpleFillStyle.esriSFSSolid;
simpleFillSymbol.Color = color == null ? GetColor(238, 205, 247) : color;
simpleFillSymbol.Outline = borderSymbol;
return simpleFillSymbol as ISymbol;
}
return null;
}
/// <summary>
/// 标注要素图层
/// </summary>
/// <param name="featureLayer">要素图层</param>
/// <param name="labelExpression">标注表达式</param>
/// <param name="labelTextSymbol">标注文字符号</param>
private void LabelFeatureLayer(IFeatureLayer featureLayer, string labelExpression, ITextSymbol labelTextSymbol)
{
//if (null == featureLayer || !featureLayer.Valid || string.IsNullOrEmpty(labelExpression)) return;
//ILabelEngineLayerProperties2 labelEngineLayerProperties = null;
//Response response = MapHelper.CreateFeatureLayerLabelProperties(featureLayer, labelExpression, labelTextSymbol, out labelEngineLayerProperties);
//if (response.Code == Constant.Success)
//{
// IAnnotateLayerProperties annotateLayerProperties = labelEngineLayerProperties as IAnnotateLayerProperties;
// IGeoFeatureLayer geoFeatureLayer = featureLayer as IGeoFeatureLayer;
// geoFeatureLayer.AnnotationProperties.Clear();
// geoFeatureLayer.AnnotationProperties.Add(annotateLayerProperties);
// geoFeatureLayer.DisplayAnnotation = true;
//}
}
public void InitCatalogContextMenus(IEnumerable<ContentMenuItemEntity> itemDatas)
{
if (itemDatas == null)
return;
if (_CmdManager == null)
_CmdManager = BundleRuntime.Instance.GetFirstOrDefaultService<ICommandManager>();
if (_MapService == null)
{
_MapService = BundleRuntime.Instance.GetFirstOrDefaultService<IMapService>();
}
if (_LayerPropertyService == null)
{
_LayerPropertyService = BundleRuntime.Instance.GetFirstOrDefaultService<ILayerPropertyService>();
}
foreach (var item in itemDatas)
{
BarItem barItem = DealWithCatalogContextMenus(item);
switch (item.ContentItemType)
{
case "Map":
popMapMenu.AddItem(barItem);
break;
case "Group":
popGroupMenu.AddItem(barItem);
break;
case "Layer":
popLayerMenu.AddItem(barItem);
break;
case "WMTSLayer":
popLayerMenu.AddItem(barItem);
break;
default:
break;
}
}
}/// <summary>
/// 将配置列表数据加载成右击菜单项
/// </summary>
/// <param name="pMenuItem"></param>
/// <returns></returns>
private BarItem DealWithCatalogContextMenus(ContentMenuItemEntity pMenuItem)
{
try
{
BarItem bar = null;
if (pMenuItem.Childs != null && pMenuItem.Childs.Count > 0)
{
bar = new BarSubItem();
bar.Caption = pMenuItem.Name;
bar.Glyph = pMenuItem.GetImage();
//创建子项
foreach (var item in pMenuItem.Childs)
{
BarItem subItem = DealWithCatalogContextMenus(item);
(bar as BarSubItem).AddItem(subItem);
barManager1.Items.Add(bar);
if (ExtendMethd.JudgeIsCouldConversionStringOrHasValue(item.ParentId) == false)
{
switch (item.ContentItemType)
{
case "Map":
popMapMenu.AddItem(subItem);
break;
case "Group":
popGroupMenu.AddItem(subItem);
break;
case "Layer":
popLayerMenu.AddItem(subItem);
break;
case "WMTSLayer":
popLayerMenu.AddItem(subItem);
break;
default:
break;
}
}
}
}
else
{
bar = new BarButtonItem();
bar.Caption = pMenuItem.Name;
bar.ItemClick += Bar_ItemClick;
bar.Glyph = pMenuItem.GetImage();
if (_CmdManager != null)
bar.Tag = _CmdManager.AddCmd(pMenuItem.CommandId, pMenuItem.Bundle, null);
if (bar.Tag is BaseMapMenuCommand && _MapService != null)
{
(bar.Tag as BaseMapMenuCommand).OnCreate(_MapService.getAxMapControl().Object);
}
else
if (bar.Tag is ICommand && _MapService != null)
{
(bar.Tag as ICommand).OnCreate(_MapService.getAxMapControl().Object);
}
barManager1.Items.Add(bar);
}
return bar;
}
catch (Exception ex)
{
LogAPI.Debug("执行 将配置列表数据加载成右击菜单项 方法时异常:" + ex + " ; ");
return null;
}
finally
{
}
}
private void Bar_ItemClick(object sender, ItemClickEventArgs e)
{
BarItem item = e.Item as BarItem;
if (item == null || item.Tag == null)
{
return;
}
try
{
if (item.Tag is ITool && _MapService != null)
{
_MapService.SetCurrentTool(item.Tag);
}
else
if (item.Tag is BaseMapMenuCommand)
{
CommandManagerInvoke.ExeCommand(item.Tag, null);
if (item is BarCheckItem)
{
(item as BarCheckItem).Checked = (item.Tag as BaseMapMenuCommand).Checked;
}
}
else
if (item.Tag is ICommand)
{
(item.Tag as ICommand).OnClick();
if (item is BarCheckItem)
{
(item as BarCheckItem).Checked = (item.Tag as ICommand).Checked;
}
}
}
catch (Exception ex)
{
LogAPI.Debug(string.Format("执行【{0}】命令异常，异常信息如下：", item.Caption));
LogAPI.Debug(ex);
LogAPI.Debug("异常信息结束");
}
}
public void InitLayerTree(IMap pMap)
{
try
{
//InitTreeNode(pMap);
}
catch (Exception ex)
{
MessageHelper.Show("初始化图层树时发生异常，异常信息请查看日志文件");
LogAPI.Debug(string.Format("初始化图层树失败：", ex.Message));
LogAPI.Debug(ex);
LogAPI.Debug("异常信息结束");
}
}
private void repositoryItemPictureEdit1_DoubleClick(object sender, EventArgs e)
{
try
{
if (null == trlProject.FocusedNode) return;
ILayer layer = trlProject.FocusedNode["Data"] as ILayer;
if (layer != null)
{
if (layer is IFeatureLayer && _LayerPropertyService != null)
{
_LayerPropertyService.SetLayerStyle(layer);
Bitmap symbol = new Bitmap(22, 16);
IGeoFeatureLayer fcLayer = layer as IGeoFeatureLayer;
if (fcLayer != null)
{
ISimpleRenderer render = fcLayer.Renderer as ISimpleRenderer;
IUniqueValueRenderer un = null;
if (render == null)
{
un = fcLayer.Renderer as IUniqueValueRenderer;
}
else
{
symbol = PreViewFillSymbol(render.Symbol, 22, 16);
}
}
byte[] bytes = null;
if (symbol == null)
{
symbol = new Bitmap(22, 16);
}
MemoryStream ms = new MemoryStream();
symbol.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);
bytes = ms.GetBuffer(); //byte[] bytes= ms.ToArray(); 这两句都可以，至于区别么，下面有解释
ms.Close();
TreeListColumn column = trlProject.Columns.ColumnByName("colSymbol");
trlProject.SetRowCellValue(trlProject.FocusedNode, column, symbol);
MapsManager.Instance.MapService.getAxMapControl().ActiveView.ContentsChanged();
MapsManager.Instance.MapService.getAxMapControl().ActiveView.PartialRefresh(esriViewDrawPhase.esriViewBackground | esriViewDrawPhase.esriViewForeground |
esriViewDrawPhase.esriViewGeography | esriViewDrawPhase.esriViewGeoSelection |
esriViewDrawPhase.esriViewGraphics | esriViewDrawPhase.esriViewGraphicSelection, null, MapsManager.Instance.MapService.getAxMapControl().ActiveView.Extent);
MapsManager.Instance.MapService.getAxMapControl().Refresh();
}
}
}
catch (Exception ex)
{
LogAPI.Debug("设置图层样式界面加载失败：" + ex);
MessageHelper.Show("设置图层样式界面加载失败：" + ex);
}
}
private void colLayerName_DoubleClick(object sender, EventArgs e)
{
}
private void btnLayerName_DoubleClick(object sender, EventArgs e)
{
try
{
//if (e.Button != MouseButtons.Left) return;
//TreeList tree = s as TreeList;
//TreeListHitInfo _hitInfo = tree.CalcHitInfo(e.Location);
//TreeListNode CurrentNode = _hitInfo.Node;
//ILayer layer = trlProject.FocusedNode.GetValue("Data") as ILayer;
if (trlProject.FocusedNode != null)
{
var Data = trlProject.FocusedNode["Data"];
if (Data is IFeatureLayer)
{
TreeListColumn column = trlProject.Columns.ColumnByName("LayerEditable");
IFeatureLayer featureLayer = Data as IFeatureLayer;
//IEngineEditor tEngineEdit = new EngineEditorClass();
IEngineEditLayers pEditLayer = _Edit as IEngineEditLayers;
//if (pEditLayer.IsEditable(featureLayer))
IWorkspace ws = (featureLayer.FeatureClass as FeatureClass).Workspace;
if (_Edit.EditState != esriEngineEditState.esriEngineStateEditing)
{
ProjectInfo ProInfo = MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo;
if (ProInfo != null)
{
_Edit.StartEditing(ws, MapsManager.Instance.MapService.getAxMapControl().Map);
}
}
else if (_Edit.EditWorkspace != ws)
{
if (_Edit.HasEdits())
{
DialogResult r = MessageHelper.ShowYesNoCancelAndTips("当前图层存在编辑为保存，是否保存编辑内容？");
if (r == DialogResult.Cancel)
return;
_Edit.StopEditing(r == DialogResult.Yes);
_Edit.StartEditing(ws, MapsManager.Instance.MapService.getAxMapControl().Map);
}
else
{
_Edit.StopEditing(false);
_Edit.StartEditing(ws, MapsManager.Instance.MapService.getAxMapControl().Map);
}
}
pEditLayer.SetTargetLayer(featureLayer, 0);
if (mCurrentEditorNode != null)
{
trlProject.SetRowCellValue(mCurrentEditorNode, "IsEdit", false);
trlProject.SetRowCellValue(mCurrentEditorNode, "ImgIndex", 0);
}
trlProject.FocusedNode.SetValue("IsEdit", true);
trlProject.FocusedNode.SetValue("ImgIndex", 1);
//trlProject.Columns["NodeName"].AppearanceCell.ForeColor = Color.Red;
mCurrentEditorNode = trlProject.FocusedNode;
}
//DataEntity nodeData = tree.GetDataRecordByNode(CurrentNode) as DataEntity;
//ResetNode(nodeData);
//ClosePopup();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
LogAPI.Debug("双击图层开启编辑失败：" + ex.Message);
}
}
private void btnLayerName_Click(object sender, EventArgs e)
{
if (e is MouseEventArgs)
{
if ((e as MouseEventArgs).Button == MouseButtons.Right)
{
MouseEventArgs eArgs = (e as MouseEventArgs);
System.Drawing.Point p = (sender as ButtonEdit).PointToScreen((e as MouseEventArgs).Location);
System.Drawing.Point p1 = trlProject.PointToClient(p);
MouseEventArgs args = new MouseEventArgs(eArgs.Button, eArgs.Clicks, p1.X, p1.Y, eArgs.Delta);
trlProject_MouseUp(trlProject, args);
}
}
}
}
public enum EnumFeatureLayerType : byte
{
Unkonwn = 0,
ShapeFileFeatureLayer = 1,
CADFeatureLayer = 2,
SurveyFeatureLayer = 3,
FileGDBFeatureLayer = 4,
PersonalGDBFeatureLayer = 5,
EnterpriseGDBFeatureLayer = 6,
CADAnnotationFeatureLayer = 7,
CoverageFeatureLayer = 8,
CoverageAnnotationFeatureLayer = 9,
}
public class NodeData
{
public int NodeID { get; set; }
public int NodePID { get; set; }
public string NodeName { get; set; }
public bool IsVisible { get; set; }
public bool IsSelectable { get; set; }
public bool IsEditable { get; set; }
public int NodeType { get; set; }
}
}