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.
4025 lines
188 KiB
4025 lines
188 KiB
using DevExpress.XtraBars; |
|
using DevExpress.XtraBars.Docking; |
|
using ESRI.ArcGIS.ADF; |
|
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.AE.Enum; |
|
using KGIS.Framework.Commands; |
|
using KGIS.Framework.DBOperator; |
|
using KGIS.Framework.Maps; |
|
using KGIS.Framework.Maps.Handlers; |
|
using KGIS.Framework.Menus; |
|
using KGIS.Framework.Menus.Entities; |
|
using KGIS.Framework.Platform; |
|
using KGIS.Framework.Utils; |
|
using KGIS.Framework.Utils.ExtensionMethod; |
|
using KGIS.Framework.Utils.Helper; |
|
//using KGIS.Framework.Utils.Model; |
|
using KGIS.Framework.Views; |
|
using Kingo.Framework.LayerStyleConvert.Common; |
|
using Kingo.Framework.LayerStyleConvert.XSDClass; |
|
using Kingo.ImageViewForWebSocket; |
|
using Kingo.KMapSDK; |
|
using Kingo.Plugin.MapView.Common; |
|
using Kingo.Plugin.MapView.Views.AppMenuView; |
|
using Kingo.PluginServiceInterface; |
|
using Kingo.PluginServiceInterface.Helper; |
|
using KUI.Windows; |
|
using System; |
|
using System.Collections.Generic; |
|
using System.Data; |
|
using System.Drawing; |
|
using System.IO; |
|
using System.Linq; |
|
using System.Runtime.InteropServices; |
|
using System.Security.AccessControl; |
|
using System.Text; |
|
using System.Windows.Forms; |
|
using System.Xml; |
|
using System.Xml.Linq; |
|
using UIShell.OSGi; |
|
using Path = System.IO.Path; |
|
using PolygonElement = KGIS.Framework.Maps.PolygonElement; |
|
|
|
namespace Kingo.Plugin.MapView |
|
{ |
|
public partial class UcMapControl : UserControl, IMapService, IDocumentView2, ICameraPoint |
|
{ |
|
public DockManager dockManager { get; private set; } |
|
private ControlsSynchronizer _CtrlSynchronizer; |
|
private object TocHook = null; |
|
private EngineEditor editor; |
|
private ControlsMapPanToolClass panTool = null; |
|
private ProjectInfo projectInfo = null; |
|
private ICommandManager _CmdManager; |
|
|
|
public event OpenedProjectHandler ProjectOpened; |
|
public event EventHandler ProjectClosed; |
|
public event EventHandler OnSelectionChanged; |
|
public event MouseEventHandler MapContainerMouseWheel; |
|
private string m_FolderPath = string.Empty; |
|
private bool m_IsLoad = true; |
|
private string m_XmlPath = AppDomain.CurrentDomain.BaseDirectory + "\\" + "ProjectPath.xml"; |
|
private string StrTig { get; set; } |
|
/// <summary> |
|
/// 工作目录服务接口 |
|
/// </summary> |
|
IDataCatalogService _DataCatalog = null; |
|
IWorkCatalog _workCatalog = null; |
|
//IEngineEditor m_EngineEditor = new EngineEditorClass(); |
|
private IElementInfo ucJCTBTree { get; set; } |
|
LayerCfg allLayerInfo = null; |
|
private UCProjectInfoSetting frmUserInfoSetting { get; set; } |
|
|
|
public UcMapControl() |
|
{ |
|
InitializeComponent(); |
|
allLayerInfo = null; |
|
EnvironmentVariables.Instance.cameraPoint = this; |
|
this.Header = "地图数据"; |
|
this.AllowClose = false; |
|
this.IsActive = true; |
|
this.AllowFloat = false; |
|
axMapControl.AutoKeyboardScrolling = false; |
|
axMapControl.OnMouseDown += AxMapControl_OnMouseDown; |
|
axMapControl.OnMouseMove += AxMapControl_OnMouseMove; |
|
axMapControl.OnMouseUp += AxMapControl_OnMouseUp; |
|
axMapControl.OnSelectionChanged += PMapCtrl_OnSelectionChanged; |
|
axMapControl.OnExtentUpdated += AxMapControl_OnExtentUpdated; |
|
if (editor == null) |
|
editor = new EngineEditorClass(); |
|
List<int> Listobjid_update = new List<int>(); |
|
List<int> Listobjid_insert = new List<int>(); |
|
editor.OnStopOperation += () => |
|
{ |
|
#region 变化图斑提取 |
|
//添加新的监测图斑时，自动维护相应的属性值 |
|
if (projectInfo != null && projectInfo.ProjType == EnumProjType.BHTBTQ) |
|
{ |
|
IWorkspaceEdit2 workspaceEdit2 = (IWorkspaceEdit2)editor.EditWorkspace; |
|
IDataChangesEx dataChangesEx = workspaceEdit2.get_EditDataChanges(esriEditDataChangesType.esriEditDataChangesWithinSession); |
|
int featureOID = -1; |
|
IFIDSet fids = dataChangesEx.ChangedIDs["JCTB", esriDifferenceType.esriDifferenceTypeInsert]; |
|
fids.Next(out featureOID); |
|
while (featureOID != -1) |
|
{ |
|
IFeatureLayer pFeatureLayer = MapsManager.Instance.MapService.GetFeatureLayerByName("JCTB"); |
|
IFeature feature = pFeatureLayer.FeatureClass.GetFeature(featureOID); |
|
feature.Value[feature.Fields.FindField("XZQDM")] = projectInfo.CODE; |
|
feature.Value[feature.Fields.FindField("XMC")] = GetXZQDic(projectInfo.CODE); |
|
IArea area = feature.ShapeCopy as IArea; |
|
IPoint point = new PointClass(); |
|
area.QueryCentroid(point); |
|
if (area.Area > 0) |
|
{ |
|
feature.Value[feature.Fields.FindField("XZB")] = point.X; |
|
feature.Value[feature.Fields.FindField("YZB")] = point.Y; |
|
feature.Value[feature.Fields.FindField("JCMJ")] = area.Area > 0 ? (area.Area / 666.7).ToDouble(2) : 0; |
|
feature.Store(); |
|
} |
|
Marshal.FinalReleaseComObject(feature); |
|
feature = null; |
|
fids.Next(out featureOID); |
|
} |
|
Marshal.FinalReleaseComObject(fids); |
|
} |
|
#endregion |
|
}; |
|
panel1.MouseWheel += MapCtrlContainer_MouseWheel; |
|
dockManager = dockManager1; |
|
Platform.Instance.NotifyMsgEven2 += o => |
|
{ |
|
switch (o.MsgType) |
|
{ |
|
case "InitProject": |
|
LoadProject(); |
|
AddMask(); |
|
break; |
|
case "SaveProject": |
|
SaveProject(); |
|
break; |
|
case "SaveProjectForNoEditor": |
|
SaveProjectForNoEditor(); |
|
break; |
|
case "LoadProject": |
|
LoadProject(o.Content.ToTrim()); |
|
break; |
|
default: |
|
break; |
|
} |
|
if (o.MsgType == "ExtentUpdated" && o.Content.ToTrim() == "Map2") |
|
{ |
|
try |
|
{ |
|
StrTig = o.Content.ToTrim(); |
|
axMapControl.ActiveView.Extent = o.Extend as IEnvelope;// MapsManager.Instance.MapService.getAxMapControl().Extent; |
|
axMapControl.ActiveView.Refresh(); |
|
} |
|
catch { } |
|
} |
|
}; |
|
} |
|
/// <summary> |
|
/// 根据区划代码获取县级名称 |
|
/// </summary> |
|
/// <param name="Codes"></param> |
|
/// <returns></returns> |
|
public string GetXZQDic(string Codes) |
|
{ |
|
IRDBHelper rdbHelper = null; |
|
string CodeName = string.Empty; |
|
try |
|
{ |
|
string systemPath = SysAppPath.GetDataBasePath() + "System.mdb"; |
|
if (File.Exists(systemPath)) |
|
{ |
|
string connStr = SysConfigsOprator.GetDBConnectionByName("MDBOledbConnection"); |
|
connStr = string.Format(connStr, systemPath); |
|
rdbHelper = RDBFactory.CreateDbHelper(connStr, DatabaseType.MSAccess); |
|
string strSQL = "select OBJECTID AS ID, XZQ AS CODE,XZQMC AS NAME from XZQ Where XZQ LIKE '" + Codes + "%'"; |
|
DataTable dt = rdbHelper.ExecuteDatatable("Dic", strSQL, true); |
|
if (dt != null) |
|
{ |
|
CodeName = dt.Rows[0]["NAME"].ToString(); |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex.Message); |
|
LogAPI.Debug(ex.StackTrace); |
|
} |
|
finally |
|
{ |
|
if (rdbHelper != null) |
|
{ |
|
rdbHelper.DisConnect(); |
|
} |
|
} |
|
return CodeName; |
|
} |
|
private void AddMask() |
|
{ |
|
try |
|
{ |
|
if (Platform.Instance.SystemType != SystemTypeEnum.BGFWCG) return; |
|
IUcZYQMagrHelper ucZYQMagrHelper = BundleRuntime.Instance.GetFirstOrDefaultService<IUcZYQMagrHelper>(); |
|
if (ucZYQMagrHelper != null) |
|
{ |
|
int selectIdZYQ = ucZYQMagrHelper.GetCheckedID(); |
|
if (selectIdZYQ < 0) return; |
|
selectIdZYQ++; |
|
IGeometry geometry = null; |
|
IFeatureClass featureClass = MapsManager.Instance.MapService.GetFeatureClassByName("ZYQ"); |
|
if (featureClass != null) |
|
{ |
|
IQueryFilter filter = new QueryFilterClass(); |
|
filter.WhereClause = string.Format("OBJECTID = {0}", selectIdZYQ); |
|
IFeatureCursor pCursor = featureClass.Search(filter, true); |
|
IFeature feature = null; |
|
if ((feature = pCursor.NextFeature()) != null) |
|
{ |
|
geometry = feature.Shape; |
|
} |
|
if (geometry != null && !geometry.IsEmpty) |
|
{ |
|
ShowMaskHelper showMaskForBHTBHelper = new ShowMaskHelper(); |
|
showMaskForBHTBHelper.axMapControl = MapsManager.Instance.MapService.getAxMapControl(); |
|
showMaskForBHTBHelper.ShowMask(geometry); |
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
|
|
return; |
|
} |
|
} |
|
private void AxMapControl_OnExtentUpdated(object sender, IMapControlEvents2_OnExtentUpdatedEvent e) |
|
{ |
|
if (StrTig != "Map2") |
|
{ |
|
Platform.Instance.SendMsg(new KGIS.Framework.Utils.Interface.NotifyMsgPackage() { MsgType = "ExtentUpdated", Content = "MainMap", Extend = e.newEnvelope }); |
|
} |
|
StrTig = ""; |
|
} |
|
|
|
private void MapCtrlContainer_MouseWheel(object sender, MouseEventArgs e) |
|
{ |
|
MapContainerMouseWheel?.Invoke(sender, e); |
|
} |
|
|
|
private void PMapCtrl_OnSelectionChanged(object sender, EventArgs e) |
|
{ |
|
OnSelectionChanged?.Invoke(sender, e); |
|
} |
|
|
|
private void AxMapControl_OnMouseUp(object sender, IMapControlEvents2_OnMouseUpEvent e) |
|
{ |
|
//滚轮按下执行地图漫游工具，拖动地图 |
|
if (e.button == 4 && panTool != null && panTool.Enabled) |
|
{ |
|
panTool.OnMouseUp(1, e.shift, e.x, e.y); |
|
panTool.Deactivate(); |
|
axMapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, axMapControl.ActiveView.Extent); |
|
} |
|
} |
|
|
|
private void AxMapControl_OnMouseMove(object sender, IMapControlEvents2_OnMouseMoveEvent e) |
|
{ |
|
//滚轮按下执行地图漫游工具，拖动地图 |
|
if (e.button == 4) |
|
{ |
|
if (panTool != null && panTool.Enabled) |
|
{ |
|
this.Cursor = global::System.Windows.Forms.Cursors.Hand; |
|
panTool.OnMouseMove(1, e.shift, e.x, e.y); |
|
} |
|
} |
|
//Platform.Instance.UpdateStateBar("", string.Format("X:{0:F3} Y:{1:F3} 当前坐标参考:{3} Unit {2}", e.mapX, e.mapY, axMapControl.Map.MapUnits, GetSpatialrefstr())); |
|
Platform.Instance.UpdateStateBar("", string.Format("X:{0:F3} Y:{1:F3} Unit {2}", e.mapX, e.mapY, axMapControl.Map.MapUnits)); |
|
} |
|
|
|
private string GetSpatialrefstr() |
|
{ |
|
string spatialrefstr = string.Empty; |
|
if (axMapControl.Map.SpatialReference == null) |
|
{ |
|
return "未知"; |
|
} |
|
IESRISpatialReferenceGEN2 prjsr = axMapControl.Map.SpatialReference as IESRISpatialReferenceGEN2; |
|
prjsr.ExportToESRISpatialReference2(out spatialrefstr, out int t); |
|
return spatialrefstr; |
|
} |
|
|
|
private void AxMapControl_OnMouseDown(object sender, IMapControlEvents2_OnMouseDownEvent e) |
|
{ |
|
if (editor == null) |
|
editor = new EngineEditorClass(); |
|
if (e.button == 2) |
|
{ |
|
//在未开启编辑状态下，地图控件上右键，则将当前工具切换至平移工具 |
|
if (this.axMapControl.CurrentTool == null || (this.axMapControl.CurrentTool.GetType() != typeof(ControlsMapPanToolClass) && editor.EditState != esriEngineEditState.esriEngineStateEditing)) |
|
{ |
|
ControlsMapPanToolClass tool = new ControlsMapPanToolClass(); |
|
tool.OnCreate(this.axMapControl.Object); |
|
this.axMapControl.CurrentTool = tool; |
|
} |
|
} |
|
else if (e.button == 4) |
|
{ |
|
//鼠标滚轮键按下 |
|
if (panTool == null) |
|
{ |
|
panTool = new ControlsMapPanToolClass(); |
|
panTool.OnCreate(axMapControl.Object); |
|
} |
|
this.Cursor = global::System.Windows.Forms.Cursors.Hand; |
|
panTool.OnMouseDown(1, e.shift, e.x, e.y); |
|
} |
|
} |
|
#region ExecuteDataCheck |
|
|
|
public void ExecuteDataCheck(IFeature feature) |
|
{ |
|
IDataCheckHelper dataCheckHelper = UIShell.OSGi.BundleRuntime.Instance.GetFirstOrDefaultService<IDataCheckHelper>(); |
|
if (dataCheckHelper == null) return; |
|
dataCheckHelper.DataCheckByThread(new CheckParametr() |
|
{ |
|
CheckType = enumCheckType.Attribute | enumCheckType.Graphic, |
|
DataSource = feature, |
|
IDataCheckName = "BGQDataCheck" |
|
}); |
|
} |
|
|
|
#endregion |
|
|
|
public UcMapControl(IBundleContext pContext, object pTocHook = null) : this() |
|
{ |
|
TocHook = pTocHook; |
|
//CtlsSynchronizer.AddFrameworkControl(TocHook); |
|
CtlsSynchronizer.ActivateMap(); |
|
InitService(pContext); |
|
//object o = MapsManager.Instance; |
|
} |
|
|
|
public void InitService(IBundleContext context) |
|
{ |
|
context.AddService<IMapService>(this); |
|
} |
|
|
|
private IWorkspace GetDefaultWorkspace(IMap pMap = null) |
|
{ |
|
IWorkspace result = null; |
|
try |
|
{ |
|
IEnumLayer enumlayer = axMapControl.Map.Layers; |
|
if (pMap != null) |
|
enumlayer = pMap.Layers; |
|
enumlayer.Reset(); |
|
ILayer layer = null; |
|
while ((layer = enumlayer.Next()) != null) |
|
{ |
|
if (!(layer is IFeatureLayer)) |
|
continue; |
|
IFeatureLayer featureLayer = layer as IFeatureLayer; |
|
if (!IsRemoteDatabase(featureLayer)) |
|
{ |
|
if (featureLayer.FeatureClass == null || !(featureLayer is IDataset)) |
|
continue; |
|
if ((featureLayer as IDataset).Workspace == null) |
|
continue; |
|
if (featureLayer is IDataset) |
|
{ |
|
string wsPath = (featureLayer as IDataset).Workspace.PathName; |
|
if (projectInfo.GetDHZSDBPath().Equals(wsPath)) |
|
{ |
|
result = (featureLayer as IDataset).Workspace; |
|
} |
|
} |
|
} |
|
} |
|
return result; |
|
} |
|
catch |
|
{ |
|
throw; |
|
} |
|
} |
|
private bool IsRemoteDatabase(IFeatureLayer pLayer) |
|
{ |
|
bool result = false; |
|
try |
|
{ |
|
if (pLayer != null && pLayer.FeatureClass != null && (pLayer.FeatureClass as FeatureClass).Workspace.Type == esriWorkspaceType.esriRemoteDatabaseWorkspace) |
|
{ |
|
result = true; |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
private string GetClassShortName(IDataset paramDS) |
|
{ |
|
if (paramDS == null) |
|
{ |
|
return ""; |
|
} |
|
return GetClassShortName(paramDS.BrowseName.ToUpper()); |
|
} |
|
private string GetClassShortName(string paramName) |
|
{ |
|
string str = paramName; |
|
int num = paramName.LastIndexOf("."); |
|
if (num >= 0) |
|
{ |
|
str = paramName.Substring(num + 1); |
|
} |
|
return str; |
|
} |
|
|
|
public List<T> GetAllLayerInGroupLayer<T>(ICompositeLayer groupLayer) |
|
{ |
|
List<T> allLayers = new List<T>(); |
|
if (groupLayer != null && groupLayer.Count > 0) |
|
{ |
|
for (int i = 0; i < groupLayer.Count; i++) |
|
{ |
|
ILayer layer = groupLayer.get_Layer(i); |
|
if (layer is ICompositeLayer && !(layer is ESRI.ArcGIS.Carto.IAnnotationLayer)) |
|
{ |
|
List<T> list = GetAllLayerInGroupLayer<T>(layer as ICompositeLayer); |
|
allLayers.AddRange(list); |
|
} |
|
else |
|
{ |
|
if (layer is T) |
|
{ |
|
allLayers.Add((T)layer); |
|
} |
|
} |
|
} |
|
} |
|
return allLayers; |
|
} |
|
public List<T> GetAllVisibleLayerInGroupLayer<T>(ICompositeLayer groupLayer) |
|
{ |
|
List<T> allLayers = new List<T>(); |
|
if (groupLayer != null && groupLayer.Count > 0) |
|
{ |
|
for (int i = 0; i < groupLayer.Count; i++) |
|
{ |
|
ILayer layer = groupLayer.get_Layer(i); |
|
if (layer is ICompositeLayer && layer.Visible && !(layer is ESRI.ArcGIS.Carto.IAnnotationLayer)) |
|
{ |
|
allLayers.AddRange(GetAllVisibleLayerInGroupLayer<T>(layer as ICompositeLayer)); |
|
} |
|
else |
|
{ |
|
if (layer is T && layer.Visible) |
|
{ |
|
if ((layer.MinimumScale == 0 || layer.MinimumScale > axMapControl.MapScale) && (layer.MaximumScale == 0 || layer.MaximumScale < axMapControl.MapScale)) |
|
allLayers.Add((T)layer); |
|
} |
|
} |
|
} |
|
} |
|
return allLayers; |
|
} |
|
|
|
|
|
/// <summary> 创建菜单项 |
|
/// </summary> |
|
/// <param name="itemEntity"></param> |
|
/// <returns></returns> |
|
private BarItem CreateItem(MenuItemEntity itemEntity, object pHook) |
|
{ |
|
try |
|
{ |
|
var itemType = itemEntity.ItemType; |
|
var item = CreateItem(itemType); |
|
item.Caption = itemEntity.Name; |
|
item.Glyph = itemEntity.GetSmallImage(); |
|
item.LargeGlyph = itemEntity.GetLargeImage(); |
|
|
|
var type = item.GetType(); |
|
//设置文本信息 |
|
var propertyInfo = type.GetProperty("Text"); |
|
if (propertyInfo != null) |
|
propertyInfo.SetValue(item, itemEntity.Name, null); |
|
//注册快捷键 |
|
//propertyInfo = type.GetProperty("ShortcutKeys"); |
|
if (!string.IsNullOrWhiteSpace(itemEntity.ShortcutKeys)) |
|
{ |
|
if (itemEntity.ShortcutKeys.Contains("+")) |
|
{ |
|
if (itemEntity.ShortcutKeys.StartsWith("Shift")) |
|
{ |
|
Keys key = GetObj<Keys>(itemEntity.ShortcutKeys.Replace("Shift+", "")); |
|
item.ItemShortcut = new BarShortcut(Keys.Shift, key); |
|
} |
|
else |
|
{ |
|
Shortcut shortcut = GetObj<Shortcut>(itemEntity.ShortcutKeys.Replace("+", "").Trim()); |
|
BarShortcut ishortcut = new BarShortcut(shortcut); |
|
item.ItemShortcut = ishortcut; |
|
} |
|
} |
|
else |
|
{ |
|
Keys key = GetObj<Keys>(itemEntity.ShortcutKeys); |
|
item.ItemShortcut = new BarShortcut(key); |
|
} |
|
|
|
} |
|
item.ItemClick += Item_ItemClick; |
|
|
|
string commandId = itemEntity.CommandId; |
|
if (!string.IsNullOrEmpty(commandId)) |
|
{ |
|
if (_CmdManager != null) |
|
{ |
|
item.Tag = _CmdManager.AddCmd(itemEntity.CommandId, itemEntity.Bundle, pHook); |
|
if (item.Tag is ICommand) |
|
{ |
|
(item.Tag as ICommand).OnCreate(axMapControl.Object); |
|
(item as BarItem).Enabled = (item.Tag as ESRI.ArcGIS.SystemUI.ICommand).Enabled; |
|
} |
|
else if (item.Tag is BaseMenuCommand) |
|
{ |
|
(item.Tag as BaseMenuCommand).OnCreate(axMapControl.Object); |
|
(item as BarItem).Enabled = (item.Tag as BaseMenuCommand).Enabled; |
|
} |
|
} |
|
} |
|
|
|
if (item is BarCheckItem && item.Tag is ESRI.ArcGIS.SystemUI.ICommand) |
|
{ |
|
(item as BarCheckItem).Checked = (item.Tag as ESRI.ArcGIS.SystemUI.ICommand).Checked; |
|
} |
|
else if (item.Tag is ICombox) |
|
{ |
|
ICombox combox = item.Tag as ICombox; |
|
combox.SetBarEditItem(item); |
|
} |
|
//CreateChildItems(item, itemEntity); |
|
|
|
return item; |
|
|
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("创建菜单项 时异常，异常信息如下："); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("创建菜单项 时异常信息结束"); |
|
|
|
throw ex; |
|
} |
|
} |
|
private T GetObj<T>(string pStr) |
|
{ |
|
T t = default(T); |
|
try |
|
{ |
|
t = (T)System.Enum.Parse(typeof(T), pStr); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
return t; |
|
} |
|
private void Item_ItemClick(object sender, ItemClickEventArgs e) |
|
{ |
|
BarItem item = e.Item as BarItem; |
|
if (item == null || item.Tag == null) |
|
{ |
|
return; |
|
} |
|
try |
|
{ |
|
if (item.Tag is ITool) |
|
{ |
|
SetCurrentTool(item.Tag); |
|
} |
|
else |
|
if (item.Tag is ICommand) |
|
{ |
|
(item.Tag as ICommand).OnClick(); |
|
if (item is BarCheckItem) |
|
{ |
|
(item as BarCheckItem).Checked = (item.Tag as ICommand).Checked; |
|
} |
|
} |
|
else |
|
if (item.Tag is IMenuCommand) |
|
{ |
|
//if (item.Tag is IAppMenuCommand) |
|
//{ |
|
// (item.Tag as IAppMenuCommand).CmdParameter = param; |
|
//} |
|
(item.Tag as IMenuCommand).OnClick(); |
|
} |
|
else |
|
{ |
|
//IMapService mapService = MapsManager.Instance.MapService; |
|
//if (mapService != null) |
|
//{ |
|
// mapService.SetCurrentTool(item.Tag); |
|
// //if (mapService.Hook is IMapControlDefault) |
|
// //{ |
|
// // (mapService.Hook as IMapControlDefault).CurrentTool = pCmd as ITool; |
|
// //} |
|
//} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(string.Format("执行【{0}】命令异常，异常信息如下：", item.Caption)); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("异常信息结束"); |
|
} |
|
} |
|
|
|
/// <summary> 创建菜单项 |
|
/// </summary> |
|
/// <param name="itemType">菜单项类型</param> |
|
private BarItem CreateItem(string itemType) |
|
{ |
|
if (string.IsNullOrWhiteSpace(itemType)) |
|
return new BarButtonItem(); |
|
|
|
BarItem item = null; |
|
switch (itemType.ToLower()) |
|
{ |
|
case "cmditem": |
|
item = new BarButtonItem(); |
|
break; |
|
case "toolitem": |
|
item = new BarCheckItem(); |
|
break; |
|
case "combobox": |
|
item = new BarEditItem(); |
|
break; |
|
case "labitem": |
|
item = new BarHeaderItem(); |
|
item.PaintStyle = BarItemPaintStyle.Caption; |
|
break; |
|
} |
|
return item; |
|
} |
|
|
|
private void MoveToCenter(List<IFeature> pFeatures) |
|
{ |
|
try |
|
{ |
|
IEnvelope pEnvelope = new EnvelopeClass() as IEnvelope; |
|
pEnvelope = pFeatures[0].ShapeCopy.Envelope; |
|
|
|
for (int i = 1; i < pFeatures.Count; i++) |
|
{ |
|
if (pEnvelope.XMax < pFeatures[i].ShapeCopy.Envelope.XMax) |
|
pEnvelope.XMax = pFeatures[i].ShapeCopy.Envelope.XMax; |
|
if (pEnvelope.XMin > pFeatures[i].ShapeCopy.Envelope.XMin) |
|
pEnvelope.XMin = pFeatures[i].ShapeCopy.Envelope.XMin; |
|
|
|
if (pEnvelope.YMax < pFeatures[i].ShapeCopy.Envelope.YMax) |
|
pEnvelope.YMax = pFeatures[i].ShapeCopy.Envelope.YMax; |
|
if (pEnvelope.YMin > pFeatures[i].ShapeCopy.Envelope.YMin) |
|
pEnvelope.YMin = pFeatures[i].ShapeCopy.Envelope.YMin; |
|
} |
|
////投影到当前地图坐标系定位缩放到当前要素 |
|
pEnvelope.Project((Hook as IMapControlDefault).SpatialReference); |
|
IUnitConverter pUnitConverter = new UnitConverterClass(); |
|
double dScale = pUnitConverter.ConvertUnits(20, esriUnits.esriMeters, (Hook as IMapControlDefault).MapUnits); |
|
pEnvelope.PutCoords(pEnvelope.XMin - dScale, pEnvelope.YMin - dScale, pEnvelope.XMax + dScale, pEnvelope.YMax + dScale); |
|
(Hook as IMapControlDefault).ActiveView.Extent = pEnvelope; |
|
(Hook as IMapControlDefault).ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, (Hook as IMapControlDefault).ActiveView.Extent); |
|
} |
|
catch (Exception ex) |
|
{ |
|
MessageHelper.ShowError("操作异常！异常信息：" + ex.Message); |
|
LogAPI.Debug(ex); |
|
} |
|
} |
|
|
|
public void SwitchWorkspace(string pDirPath) |
|
{ |
|
try |
|
{ |
|
if (!Directory.Exists(pDirPath)) |
|
{ |
|
MessageHelper.Show(string.Format("指定的工作目录{0}不存在，请重新选择!", pDirPath)); |
|
} |
|
string templatePath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "工作空间", "模板", "移动端数据制作"); |
|
ProjectInfo prj = new ProjectInfo(); |
|
prj.ProjDir = pDirPath; |
|
prj.ProjSuffix = ".prj"; |
|
prj.ProjName = "数据制作"; |
|
string prjPath = System.IO.Path.Combine(prj.ProjDir, prj.ProjName + prj.ProjSuffix); |
|
if (File.Exists(prjPath)) |
|
{ |
|
LoadProject(prjPath); |
|
} |
|
else |
|
{ |
|
if (!Directory.Exists(prj.ProjDir + "数据制作.gdb") && File.Exists(prj.ProjDir + "\\~temp.mxd")) |
|
{ |
|
File.Delete(prj.ProjDir + "\\~temp.mxd"); |
|
} |
|
DirectoryCopy(templatePath + "\\数据制作.gdb", prj.ProjDir); |
|
File.Copy(templatePath + "\\dic.mdb", prj.ProjDir + "\\dic.mdb", true); |
|
|
|
//string dicPath = System.IO.Path.Combine(SysAppPath.GetCurrentAppPath(), "Database\\dic.kzd"); |
|
//if (System.IO.File.Exists(dicPath)) |
|
//{ |
|
// File.Copy(templatePath + "\\dic.mdb", prj.ProjDir + "\\dic.mdb", true); |
|
//} |
|
FileInfo file = new FileInfo(System.IO.Path.Combine(templatePath, "数据制作.MOD")); |
|
|
|
System.IO.FileStream fileStream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None); |
|
byte[] bytes = new byte[fileStream.Length]; |
|
fileStream.Read(bytes, 0, bytes.Length); |
|
fileStream.Close(); |
|
string strBase64 = Convert.ToBase64String(bytes); |
|
prj.TempData = strBase64; |
|
if (prj.Save()) |
|
{ |
|
LoadProject(prjPath); |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
MessageHelper.Show("切换目录异常：" + ex.Message); |
|
LogAPI.Debug(ex); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 设置数据目录图层样式 |
|
/// </summary> |
|
/// <param name="layer"></param> |
|
/// <param name="element"></param> |
|
/// <returns></returns> |
|
private bool SetCatalogLayerStyle(ILayer layer, XElement element) |
|
{ |
|
bool isSet = false; |
|
try |
|
{ |
|
ESRI.ArcGIS.Geometry.esriGeometryType geometryType; |
|
IStyleGalleryClass symbologyStyleClass = null; |
|
ISymbol symbol = null; |
|
IFillSymbol fillSymbol = null; |
|
string layerCaption = element.Attribute("LayerCaption").Value; |
|
if (layerCaption == layer.Name) |
|
{ |
|
isSet = true; |
|
string layerLabelName = element.Attribute("LayerLableName").Value; |
|
int layerBorderStyle = int.Parse(element.Attribute("LayerBorderStyle").Value); |
|
double layerBorderWidth = double.Parse(element.Attribute("LayerBorderWidth").Value); |
|
Color layerFillColor = ColorTranslator.FromHtml(element.Attribute("LayerFillColor").Value); |
|
Color layerBorderColor = ColorTranslator.FromHtml(element.Attribute("LayerBorderColor").Value); |
|
Color layerLableColor = ColorTranslator.FromHtml(element.Attribute("LayerLableColor").Value); |
|
IFeatureLayer2 featureLayer = layer as IFeatureLayer2; |
|
if (featureLayer != null) |
|
{ |
|
geometryType = featureLayer.ShapeType; |
|
switch (geometryType) |
|
{ |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint: |
|
symbologyStyleClass = new MarkerSymbolStyleGalleryClassClass(); |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline: |
|
symbologyStyleClass = new LineSymbolStyleGalleryClassClass(); |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon: |
|
symbologyStyleClass = new FillSymbolStyleGalleryClassClass(); |
|
break; |
|
} |
|
ISimpleRenderer simpleRenderer = (featureLayer as IGeoFeatureLayer).Renderer as ISimpleRenderer; |
|
if (simpleRenderer != null) |
|
{ |
|
symbol = simpleRenderer.Symbol; |
|
} |
|
else |
|
{ |
|
GetDefaultSymbol(geometryType); |
|
} |
|
fillSymbol = (symbol as IFillSymbol); |
|
|
|
if (fillSymbol != null) |
|
{ |
|
//填充颜色 |
|
IColor color = fillSymbol.Color; |
|
System.Drawing.Color fillColor = System.Drawing.Color.FromArgb(layerFillColor.A, layerFillColor.R, layerFillColor.G, layerFillColor.B); |
|
color = (IColor)Converter.ToRGBColor(fillColor); |
|
color.Transparency = layerFillColor.A; |
|
fillSymbol.Color = color; |
|
|
|
|
|
//设置边框颜色、样式、宽度 |
|
ISimpleLineSymbol pMarkerLineSymbol = new SimpleLineSymbolClass(); |
|
System.Drawing.Color borderColor = System.Drawing.Color.FromArgb(layerBorderColor.A, layerBorderColor.R, layerBorderColor.G, layerBorderColor.B); |
|
IColor outlineColor = (IColor)Converter.ToRGBColor(borderColor); |
|
pMarkerLineSymbol.Width = Math.Abs(layerBorderWidth); |
|
pMarkerLineSymbol.Color = outlineColor; |
|
outlineColor.Transparency = layerBorderColor.A; |
|
|
|
if (layerBorderStyle == 0)//实线 |
|
{ |
|
pMarkerLineSymbol.Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSSolid; |
|
} |
|
else if (layerBorderStyle == 1)//虚线 |
|
{ |
|
pMarkerLineSymbol.Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSDash; |
|
} |
|
else if (layerBorderStyle == 2)//点 |
|
{ |
|
pMarkerLineSymbol.Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSDot; |
|
} |
|
else if (layerBorderStyle == 3)//点划线 |
|
{ |
|
pMarkerLineSymbol.Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSDashDot; |
|
} |
|
else if (layerBorderStyle == 4)//两点划线 |
|
{ |
|
pMarkerLineSymbol.Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSDashDotDot; |
|
} |
|
fillSymbol.Outline = pMarkerLineSymbol; |
|
|
|
if (!string.IsNullOrWhiteSpace(layerLabelName)) |
|
{ |
|
IGeoFeatureLayer pGeoFeatureLayer = layer as IGeoFeatureLayer; |
|
pGeoFeatureLayer.AnnotationProperties.Clear();//必须执行，因为里面有一个默认的 |
|
IBasicOverposterLayerProperties pBasic = new BasicOverposterLayerPropertiesClass(); |
|
ITextSymbol pTextSymbol = new TextSymbolClass(); |
|
Color textColor = System.Drawing.Color.FromArgb(layerLableColor.A, layerLableColor.R, layerLableColor.G, layerLableColor.B); |
|
IColor lableColor = (IColor)Converter.ToRGBColor(textColor); |
|
ILabelEngineLayerProperties pLableEngine = new LabelEngineLayerPropertiesClass(); |
|
pTextSymbol.Color = lableColor;//设置字体颜色 |
|
string pLable = "[" + layerLabelName + "]"; |
|
pLableEngine.Expression = pLable; |
|
pLableEngine.IsExpressionSimple = true; |
|
pBasic.NumLabelsOption = esriBasicNumLabelsOption.esriOneLabelPerShape; |
|
pLableEngine.BasicOverposterLayerProperties = pBasic; |
|
pLableEngine.Symbol = pTextSymbol; |
|
pGeoFeatureLayer.AnnotationProperties.Add(pLableEngine as IAnnotateLayerProperties); |
|
pGeoFeatureLayer.DisplayAnnotation = true; |
|
pLableEngine.Symbol = pTextSymbol; |
|
} |
|
} |
|
} |
|
} |
|
return isSet; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex.Message); |
|
return isSet; |
|
} |
|
} |
|
|
|
private ISymbol GetDefaultSymbol(ESRI.ArcGIS.Geometry.esriGeometryType geometryType) |
|
{ |
|
try |
|
{ |
|
ISymbol result = null; |
|
IRgbColor rgbColor = new RgbColorClass(); |
|
rgbColor.Red = 184; |
|
rgbColor.Green = 242; |
|
rgbColor.Blue = 200; |
|
switch (geometryType) |
|
{ |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint: |
|
result = (new SimpleMarkerSymbolClass |
|
{ |
|
Color = rgbColor, |
|
Style = ESRI.ArcGIS.Display.esriSimpleMarkerStyle.esriSMSCircle |
|
} as ISymbol); |
|
goto IL_B3; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryMultipoint: |
|
goto IL_B3; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline: |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon: |
|
result = (new SimpleFillSymbolClass |
|
{ |
|
Color = rgbColor, |
|
Style = ESRI.ArcGIS.Display.esriSimpleFillStyle.esriSFSSolid |
|
} as ISymbol); |
|
goto IL_B3; |
|
default: |
|
if (geometryType != ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryLine) |
|
{ |
|
goto IL_B3; |
|
} |
|
break; |
|
} |
|
result = (new SimpleLineSymbolClass |
|
{ |
|
Color = rgbColor, |
|
Width = 1.0, |
|
Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSSolid |
|
} as ISymbol); |
|
IL_B3: |
|
return result; |
|
} |
|
catch (Exception ex) |
|
{ |
|
//RdbUtil.AddException(ex); |
|
} |
|
return null; |
|
} |
|
public void LoadProject() |
|
{ |
|
try |
|
{ |
|
if (_workCatalog == null) |
|
{ |
|
_workCatalog = BundleRuntime.Instance.GetFirstOrDefaultService<IWorkCatalog>(); |
|
} |
|
if (Platform.Instance.SystemType == SystemTypeEnum.WYZS || Platform.Instance.SystemType == SystemTypeEnum.DTBJK || Platform.Instance.SystemType == SystemTypeEnum.YCLJK) |
|
{ |
|
string workCatalogPathTemp = null; |
|
if (Platform.Instance.SystemType == SystemTypeEnum.DTBJK) |
|
workCatalogPathTemp = SysAppPath.GetCurrentAppPath() + "DTBProject\\单图斑建库.KBG"; |
|
else if (Platform.Instance.SystemType == SystemTypeEnum.YCLJK) |
|
workCatalogPathTemp = SysAppPath.GetCurrentAppPath() + "YCLProject\\图斑预处理.KBG"; |
|
else if (Platform.Instance.SystemType == SystemTypeEnum.WYZS) |
|
workCatalogPathTemp = SysAppPath.GetCurrentAppPath() + "DTBZJProject\\单图斑质检.KBG"; |
|
if (!string.IsNullOrEmpty(workCatalogPathTemp)) |
|
{ |
|
if (File.Exists(workCatalogPathTemp)) |
|
{ |
|
LoadProject(workCatalogPathTemp); |
|
Platform.Instance.SendMsg(new KGIS.Framework.Utils.Interface.NotifyMsgPackage() { Content = Platform.Instance.SystemType, MsgType = "LoadDTBViewData" }); |
|
//SetJCTBLayer(); |
|
//LoadDTBViewData(); |
|
} |
|
else |
|
{ |
|
InitDTBProject(); |
|
//Platform.Instance.SendMsg(new KGIS.Framework.Utils.Interface.NotifyMsgPackage() { Content = Platform.Instance.SystemType, MsgType = "LoadDTBViewData" }); |
|
} |
|
return; |
|
} |
|
} |
|
string filePath = string.Empty; |
|
#region 获取上次打开的工作目录 |
|
if (File.Exists(SysAppPath.GetRecentOpenProjectRecordConfigPath())) |
|
{ |
|
XmlDocument xmlDoc = new XmlDocument(); |
|
xmlDoc.Load(SysAppPath.GetRecentOpenProjectRecordConfigPath()); |
|
string[,] RecentOpenProjectRecord_List = null; |
|
SysConfigsOprator configOp = new SysConfigsOprator(); |
|
RecentOpenProjectRecord_List = configOp.GetRecentOpenProjectRecordList(); |
|
if (RecentOpenProjectRecord_List != null) |
|
{ |
|
for (int i = 0; i < RecentOpenProjectRecord_List.Length / 3; i++) |
|
{ |
|
filePath = RecentOpenProjectRecord_List[i, 1].ToString(); |
|
if (Directory.Exists(filePath)) |
|
{ |
|
_workCatalog.SetWorksapce(filePath); |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
#endregion |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(string.Format("执行命令异常，异常信息如下：")); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("异常信息结束"); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 初始化单图斑建库工程模板 |
|
/// </summary> |
|
private void InitDTBProject() |
|
{ |
|
try |
|
{ |
|
this.ShowLoading("工程创建中……", 0, 0); |
|
string path = null; |
|
ProjectInfo pro = null; |
|
if (Platform.Instance.SystemType == SystemTypeEnum.DTBJK) |
|
{ |
|
path = SysAppPath.GetCurrentAppPath() + "DTBProject"; |
|
pro = new ProjectInfo |
|
{ |
|
ProjType = EnumProjType.DTBJK, |
|
ProjSuffix = ".KBG", |
|
ProjDir = path, |
|
ProjUserName = "今奥科技有限技术股份公司", |
|
ProjName = "单图斑建库", |
|
XYResolution = 0.0001 //默认值后续可动态配置 |
|
}; |
|
} |
|
else if (Platform.Instance.SystemType == SystemTypeEnum.YCLJK) |
|
{ |
|
path = SysAppPath.GetCurrentAppPath() + "YCLProject"; |
|
pro = new ProjectInfo |
|
{ |
|
ProjType = EnumProjType.YCLJK, |
|
ProjSuffix = ".KBG", |
|
ProjDir = path, |
|
ProjUserName = "今奥科技有限技术股份公司", |
|
ProjName = "图斑预处理", |
|
XYResolution = 0.0001 //默认值后续可动态配置 |
|
}; |
|
} |
|
else if (Platform.Instance.SystemType == SystemTypeEnum.WYZS) |
|
{ |
|
path = SysAppPath.GetCurrentAppPath() + "DTBZJProject"; |
|
pro = new ProjectInfo |
|
{ |
|
ProjType = EnumProjType.WYZS, |
|
ProjSuffix = ".KBG", |
|
ProjDir = path, |
|
ProjUserName = "今奥科技有限技术股份公司", |
|
ProjName = "单图斑质检", |
|
XYResolution = 0.0001 //默认值后续可动态配置 |
|
}; |
|
} |
|
pro.UserName = PluginServiceInterface.CommonHelper.GetAppsetingValueByKey("UserName"); |
|
//验证同名工程是否存在 |
|
if (!Directory.Exists(pro.ProjDir)) |
|
{ |
|
Directory.CreateDirectory(pro.ProjDir); |
|
} |
|
string strMxdPath = string.Empty; |
|
//单图斑建库及单图斑质检 |
|
if (Platform.Instance.SystemType == SystemTypeEnum.DTBJK || Platform.Instance.SystemType == SystemTypeEnum.WYZS) |
|
{ |
|
if (pro.ProjSuffix == ".KBG") |
|
{ |
|
strMxdPath = SysAppPath.GetCurrentAppPath() + "工作空间DTBJK\\初始化工程模板\\LatersToXMLForDTBJK.xml"; |
|
File.Copy(SysAppPath.GetCurrentAppPath() + "工作空间DTBJK\\初始化工程模板\\dic.mdb", pro.ProjDir + "\\dic.mdb", true); |
|
File.Copy(SysAppPath.GetCurrentAppPath() + "工作空间DTBJK\\初始化工程模板\\BGTJ.sqlite", pro.ProjDir + "\\BGTJ.sqlite", true); |
|
DirectoryCopy(SysAppPath.GetCurrentAppPath() + string.Format("工作空间DTBJK\\DatabaseTemplate\\JCDB.gdb"), pro.ProjDir); |
|
pro.JCDatabase = Path.Combine(pro.ProjDir, "JCDB.gdb");//监测数据图层 |
|
DirectoryCopy(SysAppPath.GetCurrentAppPath() + string.Format("工作空间DTBJK\\DatabaseTemplate\\BGDB.gdb"), pro.ProjDir); |
|
pro.BGDatabase = Path.Combine(pro.ProjDir, "BGDB.gdb"); |
|
DirectoryCopy(SysAppPath.GetCurrentAppPath() + string.Format("工作空间DTBJK\\DatabaseTemplate\\Scheme-JK.gdb"), pro.ProjDir); |
|
pro.DTBJKDatabase = Path.Combine(pro.ProjDir, "Scheme-JK.gdb"); |
|
DirectoryCopy(SysAppPath.GetCurrentAppPath() + string.Format("工作空间DTBJK\\DatabaseTemplate\\DTBDLTBBGGX.gdb"), pro.ProjDir); |
|
pro.DTBBGGXDatabase = Path.Combine(pro.ProjDir, "DTBDLTBBGGX.gdb"); |
|
DirectoryCopy(SysAppPath.GetCurrentAppPath() + string.Format("工作空间DTBJK\\DatabaseTemplate\\Check.gdb"), pro.ProjDir); |
|
pro.DTBCheckDatabase = Path.Combine(pro.ProjDir, "Check.gdb"); |
|
pro.LNGDFWPath = Path.Combine(pro.ProjDir, "Scheme-JK.gdb"); |
|
} |
|
} |
|
else if (Platform.Instance.SystemType == SystemTypeEnum.YCLJK) |
|
{ |
|
if (pro.ProjSuffix == ".KBG") |
|
{ |
|
strMxdPath = SysAppPath.GetCurrentAppPath() + "工作空间DTBJK\\初始化工程模板\\LatersToXMLForDTBYCL.xml"; |
|
File.Copy(SysAppPath.GetCurrentAppPath() + "工作空间DTBJK\\初始化工程模板\\dic.mdb", pro.ProjDir + "\\dic.mdb", true); |
|
File.Copy(SysAppPath.GetCurrentAppPath() + "工作空间DTBJK\\初始化工程模板\\BGTJ.sqlite", pro.ProjDir + "\\BGTJ.sqlite", true); |
|
DirectoryCopy(SysAppPath.GetCurrentAppPath() + string.Format("工作空间DTBJK\\DatabaseTemplate\\Scheme-YCL.gdb"), pro.ProjDir); |
|
pro.DTBYCLDatabase = Path.Combine(pro.ProjDir, "Scheme-YCL.gdb"); |
|
DirectoryCopy(SysAppPath.GetCurrentAppPath() + string.Format("工作空间DTBJK\\DatabaseTemplate\\Scheme0.gdb"), pro.ProjDir); |
|
pro.DTBYCLYHDatabase = Path.Combine(pro.ProjDir, "Scheme0.gdb"); |
|
} |
|
} |
|
|
|
LayerCfg StrLayerInfo = SerializeAPI.DeserializeToObject2<LayerCfg>(strMxdPath); |
|
StrLayerInfo.LayerName = pro.ProjName; |
|
SetLayerCfgPath(StrLayerInfo, pro); |
|
Byte[] bytearr = Encoding.Default.GetBytes(SerializeAPI.SerializeToXML<LayerCfg>(StrLayerInfo)); |
|
string strBase64 = Convert.ToBase64String(bytearr); |
|
pro.TempData = strBase64; |
|
Platform.Instance.Progress.SetWorkPath(Path.GetDirectoryName(pro.ProjDir)); |
|
this.CloseLoading(); |
|
if (pro.Save()) |
|
{ |
|
IMapService mapService = MapsManager.Instance.MapService; |
|
//设置工作目录时同时会加载 |
|
mapService.LoadProject(pro.ProjDir + "\\" + pro.ProjName + pro.ProjSuffix); |
|
mapService.SetFolderPath(pro.ProjDir); |
|
Platform.Instance.ViewManager.SetFilePath(pro.ProjDir); |
|
Platform.Instance.AppMenuManager.HideAppMenu(); |
|
} |
|
Platform.Instance.SendMsg(new KGIS.Framework.Utils.Interface.NotifyMsgPackage() { MsgType = "SaveProject" }); |
|
|
|
this.CloseLoading(); |
|
if (string.IsNullOrWhiteSpace(pro.UserName)) |
|
{ //设置单图斑工程用户信息 |
|
frmUserInfoSetting = new UCProjectInfoSetting |
|
{ |
|
WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen, |
|
}; |
|
frmUserInfoSetting.Closed += UserInfoSet_Closed; |
|
frmUserInfoSetting.ShowInMainWindow(true); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
MessageHelper.ShowError("新建工程失败：" + ex.Message); |
|
LogAPI.Debug("新建工程时发生异常，异常信息如下："); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("异常信息结束。"); |
|
} |
|
finally |
|
{ |
|
this.CloseLoading(); |
|
} |
|
} |
|
|
|
private void SetILayerSymbol(IFeatureLayer tempLayer, string LayerAliseName) |
|
{ |
|
IFeatureRenderer result = null; |
|
ISystemCfg cfg2 = BundleRuntime.Instance.GetFirstOrDefaultService<ISystemCfg>(); |
|
SystemCfg = cfg2.Load(); |
|
if (SystemCfg.BGLayerLoadCfg == null) |
|
{ |
|
SystemCfg.BGLayerLoadCfg = new List<LayerCfg>(); |
|
} |
|
LayerCfg layerCfg = SystemCfg.BGLayerLoadCfg.FirstOrDefault(x => x.FcName == LayerAliseName);//默认配置默认不为NULL |
|
if (layerCfg != null && !string.IsNullOrWhiteSpace(layerCfg.Symbol)) |
|
{ |
|
AdvancedDrawingInfo ad = AdvancedDrawingInfo.FromJson(layerCfg.Symbol); |
|
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; |
|
} |
|
} |
|
#region 样式 |
|
if (result != null) |
|
(tempLayer as IGeoFeatureLayer).Renderer = result; |
|
#endregion |
|
|
|
#region 显示比例设置 |
|
tempLayer.MinimumScale = layerCfg.MinScale; |
|
tempLayer.MaximumScale = layerCfg.MaxScale; |
|
#endregion |
|
|
|
#region 图层透明度 |
|
if (tempLayer is ILayerEffects mLayerEffects)//透明度 |
|
mLayerEffects.Transparency = (short)layerCfg.Transparency; |
|
#endregion |
|
|
|
#region 是否显示 |
|
tempLayer.Visible = layerCfg.Visible;//是否显示 |
|
#endregion |
|
|
|
#region 是否可选择 |
|
tempLayer.Selectable = layerCfg.Selectable; |
|
#endregion |
|
|
|
#region 过滤条件 |
|
IFeatureLayerDefinition pFLDefinition = tempLayer as IFeatureLayerDefinition; |
|
if (pFLDefinition != null) |
|
{ |
|
pFLDefinition.DefinitionExpression = layerCfg.DefinitionExpression; |
|
} |
|
#endregion |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 设置默认数据库模板图层路径 |
|
/// </summary> |
|
/// <param name="StrLayerInfo"></param> |
|
/// <param name="pro"></param> |
|
private void SetLayerCfgPath(LayerCfg StrLayerInfo, ProjectInfo pro) |
|
{ |
|
foreach (LayerCfg CfgItem in StrLayerInfo.Layers)//目录图层一级 |
|
{ |
|
if (CfgItem.LayerType == EnumLayerType.GroupLayer) |
|
{ |
|
SetLayerCfgPath(CfgItem, pro); |
|
} |
|
else if (CfgItem.LayerType == EnumLayerType.FeatureLayer) |
|
{ |
|
if (Platform.Instance.SystemType == SystemTypeEnum.YCLJK) |
|
{ |
|
if ("标注点,标注线,标注面,自主图斑".Contains(CfgItem.LayerName)) |
|
CfgItem.FcPath = pro.DTBYCLYHDatabase; |
|
else |
|
CfgItem.FcPath = pro.DTBYCLDatabase; |
|
} |
|
else |
|
{ |
|
if ("单图斑地类图斑更新层,推土区更新".Contains(CfgItem.LayerName)) |
|
CfgItem.FcPath = pro.DTBBGGXDatabase; |
|
else |
|
CfgItem.FcPath = pro.DTBJKDatabase; |
|
} |
|
} |
|
} |
|
} |
|
|
|
private void UserInfoSet_Closed(object sender, EventArgs e) |
|
{ |
|
try |
|
{ |
|
ProjectInfo projectInfo = MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo; |
|
if (frmUserInfoSetting != null) |
|
{ |
|
frmUserInfoSetting.Close(); |
|
frmUserInfoSetting = null; |
|
} |
|
if (frmUserInfoSetting == null && string.IsNullOrWhiteSpace(projectInfo.UserName)) |
|
{ |
|
MessageHelper.Show("请输入用户名！"); |
|
frmUserInfoSetting = new UCProjectInfoSetting |
|
{ |
|
WindowStartupLocation = System.Windows.WindowStartupLocation.CenterScreen, |
|
}; |
|
frmUserInfoSetting.Closed += UserInfoSet_Closed; |
|
frmUserInfoSetting.ShowInMainWindow(true); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 文件夹复制 |
|
/// </summary> |
|
/// <param name="sourceDir">原文件夹</param> |
|
/// <param name="targetDirPath">目标目录</param> |
|
/// <returns>是否成功复制</returns> |
|
public bool DirectoryCopy(string sourceDir, string targetDirPath) |
|
{ |
|
try |
|
{ |
|
if (!System.IO.Directory.Exists(sourceDir)) return false; |
|
string targetDir = targetDirPath + "\\" + System.IO.Path.GetFileName(sourceDir); |
|
if (!System.IO.Directory.Exists(targetDir)) System.IO.Directory.CreateDirectory(targetDir); |
|
// 文件及文件夹名称数组 |
|
string[] dirColl = System.IO.Directory.GetDirectories(sourceDir); |
|
string[] fileColl = System.IO.Directory.GetFiles(sourceDir); |
|
// 便利所有文件 |
|
if (fileColl.Length > 0) |
|
{ |
|
string fileName; |
|
foreach (string fileDir in fileColl) |
|
{ |
|
fileName = System.IO.Path.GetFileName(fileDir); |
|
System.IO.File.Copy(sourceDir + "\\" + fileName, targetDir + "\\" + fileName, true); |
|
} |
|
} |
|
// 遍历所有文件夹 |
|
if (dirColl.Length > 0) |
|
{ |
|
string folderName; |
|
foreach (string dir in dirColl) |
|
{ |
|
folderName = System.IO.Path.GetFileName(dir); |
|
// 递归调用 |
|
System.IO.Directory.CreateDirectory(targetDir + "\\" + folderName); |
|
DirectoryCopy(dir, targetDir + "\\" + folderName); |
|
} |
|
} |
|
return true; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("新建工程 页面 中 文件夹复制 时失败，异常原因: " + ex + " ; "); |
|
|
|
return false; |
|
throw; |
|
} |
|
} |
|
|
|
private void LoadMap(string filePath) |
|
{ |
|
try |
|
{ |
|
axMapControl.CurrentTool = null; |
|
projectInfo = new ProjectInfo(); |
|
projectInfo.ProjName = System.IO.Path.GetFileNameWithoutExtension(filePath); |
|
projectInfo.ProjSuffix = System.IO.Path.GetExtension(filePath); |
|
projectInfo.ProjDir = System.IO.Path.GetDirectoryName(filePath); |
|
IMapDocument mDoc = new MapDocumentClass(); |
|
mDoc.Open(filePath); |
|
|
|
IMap map = mDoc.get_Map(0); |
|
if (map == null) |
|
return; |
|
map.Name = projectInfo.ProjName; |
|
ISpatialReference reference = GeoDBAPI.GetGeoDatasetSpatialReference(GetDefaultWorkspace(map)); |
|
if (map.SpatialReference != reference && reference != null) |
|
{ |
|
map.SpatialReference = reference; |
|
} |
|
IActiveView view = (IActiveView)map; |
|
mDoc.SetActiveView(view); |
|
CtlsSynchronizer.ReplaceMap(map); |
|
axMapControl.DocumentFilename = filePath; |
|
mDoc.Close(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
private void CreateXml(string path) |
|
{ |
|
try |
|
{ |
|
System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument(); |
|
xmlDoc.AppendChild(xmlDoc.CreateXmlDeclaration("1.0", "UTF-8", null)); |
|
System.Xml.XmlElement root = xmlDoc.CreateElement("Root"); |
|
xmlDoc.AppendChild(root); |
|
|
|
System.Xml.XmlElement roots = xmlDoc.CreateElement("File"); |
|
roots.SetAttribute("path", path); |
|
root.AppendChild(roots); |
|
xmlDoc.Save(m_XmlPath); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("在初始化 目录切换 命令时异常，异常信息如下："); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("在初始化 目录切换 命令时异常信息结束"); |
|
} |
|
} |
|
|
|
#region 接口函数 |
|
public void InitMapTools(IEnumerable<MenuPageEntity> pageDatas) |
|
{ |
|
try |
|
{ |
|
if (barManager1 == null) return; |
|
barManager1.BeginUpdate(); |
|
if (_CmdManager == null) |
|
{ |
|
_CmdManager = BundleRuntime.Instance.GetFirstOrDefaultService<ICommandManager>(); |
|
} |
|
foreach (var pageEntity in pageDatas) |
|
{ |
|
var groupChilds = pageEntity.Childs; |
|
if (groupChilds == null) |
|
continue; |
|
foreach (var groupChild in groupChilds) |
|
{ |
|
Bar subItem = new Bar(); |
|
subItem.OptionsBar.AllowQuickCustomization = false; |
|
//禅道BUG9359 修改人员：王冠杰 禁止关闭工具栏，仅允许用户在界面拖动工具栏 |
|
subItem.OptionsBar.DisableClose = true;//禁用关闭 |
|
subItem.BarName = groupChild.Name; |
|
subItem.Visible = groupChild.Visible; |
|
if (groupChild.Name == "地图操作") |
|
{ |
|
subItem.DockStyle = BarDockStyle.Left; |
|
} |
|
else |
|
{ |
|
subItem.DockStyle = BarDockStyle.Top; |
|
} |
|
barManager1.Bars.Add(subItem); |
|
|
|
var itemChilds = groupChild.Childs; |
|
if (itemChilds == null) |
|
continue; |
|
foreach (var itemChild in itemChilds) |
|
{ |
|
var item = CreateItem(itemChild, Hook); |
|
//item.PaintStyle = BarItemPaintStyle.Caption; |
|
//subItem.LinksPersistInfo.Add(new LinkPersistInfo(DevExpress.XtraBars.BarLinkUserDefines.PaintStyle, item, "", false, true, true, 0, null, DevExpress.XtraBars.BarItemPaintStyle.CaptionGlyph)); |
|
subItem.LinksPersistInfo.Add(new LinkPersistInfo(item)); |
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("加载主菜单异常，异常信息如下："); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("异常信息结束"); |
|
} |
|
finally |
|
{ |
|
barManager1.EndUpdate(); |
|
} |
|
} |
|
public void RefreshToolState(object currentTool) |
|
{ |
|
try |
|
{ |
|
if (barManager1 == null) return; |
|
foreach (Bar bar in barManager1.Bars) |
|
{ |
|
foreach (LinkPersistInfo linkPersist in bar.LinksPersistInfo) |
|
{ |
|
BarItem item = linkPersist.Item; |
|
if (item.Tag is ICommand) |
|
{ |
|
item.Enabled = (item.Tag as ICommand).Enabled; |
|
if (item is BarCheckItem) |
|
{ |
|
(item as BarCheckItem).Checked = (item.Tag as ICommand).Checked; |
|
|
|
if (currentTool == item.Tag) |
|
{ |
|
(item as BarCheckItem).Checked = true; |
|
} |
|
} |
|
} |
|
else if (item.Tag is BaseMenuCommand) |
|
{ |
|
item.Enabled = (item.Tag as BaseMenuCommand).Enabled; |
|
if (item is BarCheckItem) |
|
{ |
|
(item as BarCheckItem).Checked = (item.Tag as BaseMenuCommand).Checked; |
|
|
|
if (currentTool == item.Tag) |
|
{ |
|
(item as BarCheckItem).Checked = true; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("刷新工具条状态时发生异常，异常信息如下："); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("异常信息结束"); |
|
} |
|
} |
|
private IFeatureRenderer GetSymbol(string pStrSymbol) |
|
{ |
|
IFeatureRenderer result = null; |
|
try |
|
{ |
|
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; |
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("获取图层样式失败：" + ex.Message); |
|
} |
|
return result; |
|
} |
|
private void LaodLayersToMap(ILayer addLayerTemp, List<LayerCfg> layerInfo2s) |
|
{ |
|
foreach (var item in layerInfo2s) |
|
{ |
|
ILayer addLayer = null; |
|
if (item.LayerType == EnumLayerType.GroupLayer) |
|
{ |
|
addLayer = new GroupLayer() { Name = item.LayerName }; |
|
ILayerGeneralProperties layerGeneralProperties = addLayer as ILayerGeneralProperties; |
|
layerGeneralProperties.LayerDescription = item.FcName; |
|
} |
|
foreach (LayerCfg subItem in item.Layers) |
|
{ |
|
// LayerCfg GroupLayerInfo = null; |
|
if (subItem.LayerType == EnumLayerType.GroupLayer) |
|
{ |
|
ILayer groupLayer = new GroupLayer() { Name = subItem.LayerName }; |
|
ILayerGeneralProperties layerGeneralProperties = addLayer as ILayerGeneralProperties; |
|
layerGeneralProperties.LayerDescription = subItem.FcName; |
|
//GroupLayerInfo = _DataCatalog.AddLayer(groupLayer, addLayer as IGroupLayer) as LayerCfg; |
|
//(addLayer as IGroupLayer).Add(addLayer); |
|
subItem.Data = groupLayer; |
|
LaodLayersToMap(groupLayer, item.Layers);//Group-Group |
|
} |
|
//工程文件夹或被移动-替换工作目录 |
|
if (!string.IsNullOrWhiteSpace(subItem.FcPath) && projectInfo.ProWorkDir != null && _workCatalog.SaveWorkSapcePath != null) |
|
{ |
|
subItem.FcPath = subItem.FcPath.ToString().Replace(projectInfo.ProWorkDir, _workCatalog.SaveWorkSapcePath); |
|
} |
|
|
|
if (addLayer is IGroupLayer && subItem.LayerType == EnumLayerType.FeatureLayer) |
|
{ |
|
if (string.IsNullOrWhiteSpace(subItem.FcPath)) continue; |
|
WorkspaceTypeEnum workspaceType = WorkspaceTypeEnum.GDBFile; |
|
if (subItem.FcPath.ToLower().EndsWith(".mdb")) |
|
{ |
|
if (!File.Exists(subItem.FcPath)) |
|
{ |
|
continue; |
|
} |
|
workspaceType = WorkspaceTypeEnum.MDBFile; |
|
} |
|
else |
|
{ |
|
if (!Directory.Exists(subItem.FcPath)) continue; |
|
workspaceType = WorkspaceTypeEnum.ShapeFile; |
|
if (subItem.FcPath.ToLower().EndsWith(".gdb")) |
|
{ |
|
workspaceType = WorkspaceTypeEnum.GDBFile; |
|
} |
|
} |
|
IWorkspaceAPI wsAPI = new WorkspaceAPI(subItem.FcPath, workspaceType); |
|
IFeatureClass fc = wsAPI.OpenFeatureClass(subItem.FcName).FeatureClass; |
|
ILayer tempLayer = new FeatureLayer() { Name = subItem.LayerName, FeatureClass = fc }; |
|
IFeatureRenderer render = GetSymbol(subItem.Symbol); |
|
if (render != null) |
|
(tempLayer as IGeoFeatureLayer).Renderer = render; |
|
//(addLayer as IGroupLayer).Add(tempLayer); |
|
_DataCatalog.AddLayer(tempLayer, addLayer); |
|
subItem.Data = tempLayer; |
|
} |
|
else if (addLayer is IGroupLayer && subItem.LayerType == EnumLayerType.RasterLayer) |
|
{ |
|
if (string.IsNullOrWhiteSpace(subItem.FcPath)) continue; |
|
IRasterLayer layer = new RasterLayerClass(); |
|
layer.CreateFromFilePath(subItem.FcPath); |
|
layer.Name = subItem.LayerName; |
|
//(addLayer as IGroupLayer).Add(layer); |
|
_DataCatalog.AddLayer(layer, addLayer); |
|
subItem.Data = layer; |
|
} |
|
else if (addLayer is IGroupLayer && subItem.LayerType == EnumLayerType.KOTilesLayer) |
|
{ |
|
if (string.IsNullOrWhiteSpace(subItem.FcPath)) continue; |
|
KOTilesLayer ko = KOTilesLayer.CreateInstance(subItem.FcPath); |
|
ko.Name = subItem.LayerName; |
|
//(addLayer as IGroupLayer).Add(ko); |
|
_DataCatalog.AddLayer(ko, addLayer); |
|
subItem.Data = ko; |
|
} |
|
} |
|
if (addLayer != null) |
|
axMapControl.Map.AddLayer(addLayer); |
|
} |
|
} |
|
public SystemConfig2 SystemCfg { get; set; } |
|
private void LoadLayerToMap(LayerCfg ParentGroup, List<LayerCfg> layerInfo2s) |
|
{ |
|
try |
|
{ |
|
for (int i = 0; i < layerInfo2s.Count; i++) |
|
{ |
|
IGroupLayer rootGroupLayer = null; |
|
LayerCfg GroupLayerInfo = null; |
|
if (layerInfo2s[i].LayerType == EnumLayerType.GroupLayer) |
|
{ |
|
rootGroupLayer = new GroupLayer() { Name = layerInfo2s[i].LayerName }; |
|
ILayerGeneralProperties layerGeneralProperties = rootGroupLayer as ILayerGeneralProperties; |
|
layerGeneralProperties.LayerDescription = layerInfo2s[i].FcName; |
|
GroupLayerInfo = _DataCatalog.AddLayer(rootGroupLayer, ParentGroup) as LayerCfg; |
|
layerInfo2s[i].Symbol = GroupLayerInfo.Symbol; |
|
layerInfo2s[i].SymbolImg = GroupLayerInfo.SymbolImg; |
|
layerInfo2s[i].Data = GroupLayerInfo.Data; |
|
LoadLayerToMap(GroupLayerInfo, layerInfo2s[i].Layers); |
|
} |
|
else |
|
{ |
|
GroupLayerInfo = GroupLayerInfo ?? ParentGroup; |
|
if (Platform.Instance.SystemType != SystemTypeEnum.WYZS && Platform.Instance.SystemType != SystemTypeEnum.DTBJK && Platform.Instance.SystemType != SystemTypeEnum.YCLJK) |
|
{ |
|
layerInfo2s[i].FcPath = layerInfo2s[i].FcPath.Replace("{工程目录}", projectInfo.ProjDir); |
|
layerInfo2s[i].FcPath = layerInfo2s[i].FcPath.Replace("{工作目录}", projectInfo.ProWorkDir); |
|
//工程文件夹或被移动-替换工作目录 AddLayerWay-外部路径文件 |
|
if (projectInfo.ProjType != EnumProjType.BHTBTQ && layerInfo2s[i].AbsolutePathType != "AddLayerWay" && !string.IsNullOrWhiteSpace(layerInfo2s[i].FcPath) && projectInfo.ProWorkDir != null && _workCatalog.SaveWorkSapcePath != null) |
|
{ |
|
if (layerInfo2s[i].FcPath.ToLower().EndsWith(".mdb") || layerInfo2s[i].FcPath.ToLower().EndsWith(".gdb")) |
|
{ |
|
if (layerInfo2s[i].FcPath.Contains(projectInfo.ProWorkDir)) |
|
{ |
|
string Temppath = layerInfo2s[i].FcPath.ToString().Replace(projectInfo.ProWorkDir, "|"); |
|
layerInfo2s[i].FcPath = System.IO.Path.Combine(_workCatalog.SaveWorkSapcePath, projectInfo.ProWorkDir + Temppath.Split('|')[Temppath.Split('|').Length - 1].ToString()); |
|
} |
|
else |
|
{ |
|
string Temppath = layerInfo2s[i].FcPath.ToString().Replace("\\", "|"); |
|
layerInfo2s[i].FcPath = System.IO.Path.Combine(_workCatalog.SaveWorkSapcePath, projectInfo.ProWorkDir, "参考数据", Temppath.Split('|')[Temppath.Split('|').Length - 1].ToString()); |
|
} |
|
} |
|
} |
|
} |
|
LayerCfg layerInfo3 = new LayerCfg(); |
|
if (layerInfo2s[i].LayerType == EnumLayerType.FeatureLayer) |
|
{ |
|
string sdf = layerInfo2s[i].LayerName; |
|
ILayer tempLayer = null; |
|
if (!string.IsNullOrWhiteSpace(layerInfo2s[i].FcPath)) |
|
{ |
|
WorkspaceTypeEnum workspaceType = WorkspaceTypeEnum.GDBFile; |
|
if (layerInfo2s[i].FcPath.ToLower().EndsWith(".mdb")) |
|
{ |
|
if (!File.Exists(layerInfo2s[i].FcPath)) |
|
{ |
|
if (Platform.Instance.SystemType != SystemTypeEnum.DTBJK) |
|
{ |
|
layerInfo2s.Remove(layerInfo2s[i]); |
|
i--; |
|
} |
|
continue; |
|
} |
|
workspaceType = WorkspaceTypeEnum.MDBFile; |
|
} |
|
else if (layerInfo2s[i].FcPath.ToLower().EndsWith(".gdb")) |
|
{ |
|
if (!Directory.Exists(layerInfo2s[i].FcPath)) |
|
{ |
|
if(Platform.Instance.SystemType != SystemTypeEnum.DTBJK) |
|
{ |
|
layerInfo2s.Remove(layerInfo2s[i]); |
|
i--; |
|
} |
|
continue; |
|
} |
|
workspaceType = WorkspaceTypeEnum.GDBFile; |
|
} |
|
else |
|
{ |
|
workspaceType = WorkspaceTypeEnum.ShapeFile; |
|
} |
|
IWorkspaceAPI wsAPI = null; |
|
if (workspaceType == WorkspaceTypeEnum.GDBFile) |
|
wsAPI = new WorkspaceAPI(layerInfo2s[i].FcPath, workspaceType, true); |
|
else |
|
wsAPI = new WorkspaceAPI(layerInfo2s[i].FcPath, workspaceType); |
|
if (wsAPI.OpenFeatureClass2(layerInfo2s[i].FcName) != null) |
|
{ |
|
IFeatureClass fc = wsAPI.OpenFeatureClass(layerInfo2s[i].FcName).FeatureClass; |
|
tempLayer = new FeatureLayer() { Name = layerInfo2s[i].LayerName, FeatureClass = fc }; |
|
} |
|
wsAPI.CloseWorkspace(); |
|
wsAPI = null; |
|
} |
|
else if (string.IsNullOrWhiteSpace(layerInfo2s[i].FcPath) && Platform.Instance.SystemType != SystemTypeEnum.DTBJK && Platform.Instance.SystemType != SystemTypeEnum.YCLJK) |
|
continue; |
|
if (tempLayer == null) |
|
tempLayer = GetFeatureLayerByBasicPath(layerInfo2s[i]);// new FeatureLayer() { Name = layerInfo2s[i].LayerName }; |
|
#region 显示比例设置 |
|
sdf = tempLayer.Name; |
|
tempLayer.MinimumScale = layerInfo2s[i].MinScale; |
|
tempLayer.MaximumScale = layerInfo2s[i].MaxScale; |
|
#endregion |
|
|
|
#region 图层透明度 |
|
if (tempLayer is ILayerEffects mLayerEffects)//透明度 |
|
mLayerEffects.Transparency = (short)layerInfo2s[i].Transparency; |
|
#endregion |
|
|
|
#region 是否显示 |
|
tempLayer.Visible = layerInfo2s[i].Visible;//是否显示 |
|
#endregion |
|
|
|
#region 过滤条件 |
|
IFeatureLayerDefinition pFLDefinition = tempLayer as IFeatureLayerDefinition; |
|
if (pFLDefinition != null) |
|
{ |
|
pFLDefinition.DefinitionExpression = layerInfo2s[i].DefinitionExpression; |
|
} |
|
#endregion |
|
|
|
#region 图层样式 |
|
IFeatureRenderer render = GetSymbol(layerInfo2s[i].Symbol); |
|
if (render != null) |
|
(tempLayer as IGeoFeatureLayer).Renderer = render; |
|
#endregion |
|
|
|
#region 图层标注 |
|
SetLayerAnnotation(tempLayer, layerInfo2s[i]); |
|
#endregion |
|
|
|
layerInfo2s[i].Data = tempLayer; |
|
tempLayer.Visible = layerInfo2s[i].Visible == false ? false : GetParentIsChecked(layerInfo2s[i]); |
|
LayerCfg newLayerCfg = _DataCatalog.AddLayer(tempLayer, GroupLayerInfo) as LayerCfg; |
|
layerInfo2s[i].Symbol = newLayerCfg.Symbol ?? layerInfo2s[i].Symbol; |
|
layerInfo2s[i].SymbolImg = newLayerCfg.SymbolImg; |
|
layerInfo2s[i].Data = newLayerCfg.Data; |
|
var layerCfg = SystemCfg.ZLLayerLoadCfg.FirstOrDefault(x => x.LayerName == "增量成果"); |
|
if (layerCfg != null) |
|
{ |
|
var ilayerCfg = layerCfg.Layers.FirstOrDefault(x => x.LayerName == tempLayer.Name); |
|
if (ilayerCfg != null) |
|
{ |
|
layerInfo2s[i].FieldEditCfg = ilayerCfg.FieldEditCfg; |
|
} |
|
} |
|
layerInfo3 = GroupLayerInfo.Layers.FirstOrDefault(x => x.FcName == tempLayer.Name); |
|
} |
|
else if (layerInfo2s[i].LayerType == EnumLayerType.RasterLayer) |
|
{ |
|
if (string.IsNullOrWhiteSpace(layerInfo2s[i].FcPath)) continue; |
|
IRasterLayer layer = new RasterLayerClass(); |
|
layer.CreateFromFilePath(layerInfo2s[i].FcPath); |
|
layer.Name = layerInfo2s[i].LayerName; |
|
LayerCfg layerCfg = SystemCfg.JcLayerLoadCfg.FirstOrDefault(x => x.LayerName == layer.Name); |
|
if (layerCfg != null) |
|
{ |
|
layer.MinimumScale = layerCfg.MinScale; |
|
layer.MaximumScale = layerCfg.MaxScale; |
|
} |
|
if (layer is ILayerEffects mLayerEffects) |
|
mLayerEffects.Transparency = (short)layerInfo2s[i].Transparency; |
|
layer.Visible = layerInfo2s[i].Visible; |
|
layerInfo2s[i].Data = layer; |
|
layer.Visible = layerInfo2s[i].Visible == false ? false : GetParentIsChecked(layerInfo2s[i]); |
|
_DataCatalog.AddLayer(layer, GroupLayerInfo); |
|
layerInfo3 = GroupLayerInfo.Layers.FirstOrDefault(x => x.FcName == layer.Name); |
|
} |
|
else if (layerInfo2s[i].LayerType == EnumLayerType.KOTilesLayer) |
|
{ |
|
if (string.IsNullOrWhiteSpace(layerInfo2s[i].FcPath)) continue; |
|
KOTilesLayer ko = KOTilesLayer.CreateInstance(layerInfo2s[i].FcPath); |
|
ko.Name = layerInfo2s[i].LayerName; |
|
LayerCfg layerCfg = SystemCfg.JcLayerLoadCfg.FirstOrDefault(x => x.LayerName == ko.Name); |
|
if (layerCfg != null) |
|
{ |
|
ko.MinimumScale = layerCfg.MinScale; |
|
ko.MaximumScale = layerCfg.MaxScale; |
|
} |
|
if (ko is ILayerEffects mLayerEffects) |
|
mLayerEffects.Transparency = (short)layerInfo2s[i].Transparency; |
|
ko.Visible = layerInfo2s[i].Visible; |
|
layerInfo2s[i].Data = ko; |
|
ko.Visible = layerInfo2s[i].Visible == false ? false : GetParentIsChecked(layerInfo2s[i]); |
|
_DataCatalog.AddLayer(ko, GroupLayerInfo); |
|
layerInfo3 = GroupLayerInfo.Layers.FirstOrDefault(x => x.FcName == ko.Name); |
|
} |
|
else if (layerInfo2s[i].LayerType == EnumLayerType.WMTSLayer) |
|
{ |
|
} |
|
if (layerInfo3 != null) |
|
{ |
|
layerInfo3.AbsolutePathType = layerInfo2s[i].AbsolutePathType; |
|
layerInfo3.AbsolutePath = layerInfo2s[i].AbsolutePath; |
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("LoadLayerToMap异常：" + ex.Message); |
|
LogAPI.Debug("LoadLayerToMap异常：" + ex.StackTrace); |
|
} |
|
} |
|
|
|
#region 大数据影像相关 |
|
public Dictionary<ILayer, ILayer> GetAllLayerInGroupLayer(ICompositeLayer groupLayer, ILayer parentLayer) |
|
{ |
|
Dictionary<ILayer, ILayer> allLayers = new Dictionary<ILayer, ILayer>(); |
|
if (groupLayer != null && groupLayer.Count > 0) |
|
{ |
|
for (int i = 0; i < groupLayer.Count; i++) |
|
{ |
|
ILayer layer = groupLayer.get_Layer(i); |
|
if (layer is ICompositeLayer && !(layer is ESRI.ArcGIS.Carto.IAnnotationLayer)) |
|
{ |
|
if (!allLayers.Keys.Contains(layer)) |
|
allLayers.Add(layer, parentLayer); |
|
Dictionary<ILayer, ILayer> list = GetChildLayerInGroupLayer(layer as ICompositeLayer, layer); |
|
foreach (var item in list) |
|
{ |
|
if (!allLayers.Keys.Contains(item.Key)) |
|
{ |
|
allLayers.Add(item.Key, item.Value); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
if (layer is ILayer) |
|
{ |
|
if (!allLayers.Keys.Contains(layer)) |
|
allLayers.Add(layer, parentLayer); |
|
} |
|
} |
|
} |
|
} |
|
return allLayers; |
|
} |
|
public Dictionary<ILayer, ILayer> GetChildLayerInGroupLayer(ICompositeLayer groupLayer, ILayer parentLayer) |
|
{ |
|
Dictionary<ILayer, ILayer> allLayers = new Dictionary<ILayer, ILayer>(); |
|
if (groupLayer != null && groupLayer.Count > 0) |
|
{ |
|
for (int i = 0; i < groupLayer.Count; i++) |
|
{ |
|
ILayer layer = groupLayer.get_Layer(i); |
|
if (layer is ICompositeLayer && !(layer is ESRI.ArcGIS.Carto.IAnnotationLayer)) |
|
{ |
|
if (!allLayers.Keys.Contains(layer)) |
|
allLayers.Add(layer, parentLayer); |
|
} |
|
else |
|
{ |
|
if (layer is ILayer) |
|
{ |
|
if (!allLayers.Keys.Contains(layer)) |
|
allLayers.Add(layer, parentLayer); |
|
} |
|
} |
|
} |
|
} |
|
return allLayers; |
|
} |
|
#endregion |
|
|
|
/// <summary> |
|
/// 获取模版数据库要素类 |
|
/// </summary> |
|
/// <param name="layerCfg"></param> |
|
/// <returns></returns> |
|
private IFeatureLayer GetFeatureLayerByBasicPath(LayerCfg layerCfg) |
|
{ |
|
IFeatureLayer featureLayer = null; |
|
IWorkspaceAPI wsAPI = null; |
|
try |
|
{ |
|
if (projectInfo == null) |
|
projectInfo = MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo; |
|
string BasicPath = string.Empty; |
|
switch (layerCfg.LayerName) |
|
{ |
|
case "质检结果": |
|
BasicPath = projectInfo.DTBCheckDatabase; |
|
break; |
|
case "基础_历年耕地": |
|
BasicPath = projectInfo.DTBJKDatabase; |
|
break; |
|
default: |
|
break; |
|
} |
|
if (string.IsNullOrWhiteSpace(BasicPath)) |
|
return featureLayer ?? new FeatureLayer() { Name = layerCfg.LayerName }; |
|
wsAPI = new WorkspaceAPI(BasicPath, WorkspaceTypeEnum.GDBFile, true); |
|
if (wsAPI.ExistFeatureClass(layerCfg.FcName)) |
|
{ |
|
IFeatureClass fc = wsAPI.OpenFeatureClass(layerCfg.FcName).FeatureClass; |
|
featureLayer = new FeatureLayer() { Name = layerCfg.LayerName, FeatureClass = fc }; |
|
} |
|
return featureLayer ?? new FeatureLayer() { Name = layerCfg.LayerName }; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("获取模版数据库要素类失败：" + ex); |
|
return featureLayer ?? new FeatureLayer() { Name = layerCfg.LayerName }; |
|
} |
|
finally |
|
{ |
|
if (wsAPI != null) |
|
wsAPI.CloseWorkspace(); |
|
} |
|
} |
|
|
|
private bool GetParentIsChecked(LayerCfg layer) |
|
{ |
|
if (allLayerInfo == null) return true; |
|
LayerCfg parent = allLayerInfo.GetAllItem().Find(a => a.Layers.Contains(layer)); |
|
if (parent == null) |
|
{ |
|
return true; |
|
} |
|
else if (!parent.Visible) |
|
{ |
|
return false; |
|
} |
|
else |
|
{ |
|
return GetParentIsChecked(parent); |
|
} |
|
} |
|
|
|
public void LoadProject(string pPrjFile) |
|
{ |
|
try |
|
{ |
|
DateTime time = DateTime.Now; |
|
EngineEditor engineEditor = new EngineEditor(); |
|
if (engineEditor.EditState == esriEngineEditState.esriEngineStateEditing) |
|
{ |
|
MessageHelper.ShowTips("当前处于编辑状态，请关闭后打开工程！"); |
|
return; |
|
} |
|
if (_DataCatalog == null) |
|
_DataCatalog = BundleRuntime.Instance.GetFirstOrDefaultService<IDataCatalogService>(); |
|
CloseProject(); |
|
projectInfo = ProjectInfo.OpenProject(pPrjFile); |
|
if (projectInfo == null) |
|
{ |
|
MessageHelper.ShowError("加载工程失败！"); |
|
return; |
|
} |
|
axMapControl.CurrentTool = null; |
|
if (projectInfo != null && !string.IsNullOrWhiteSpace(projectInfo.TempData)) |
|
{ |
|
#region 将文件流转换成文件存储到本地 |
|
byte[] contentArray = Convert.FromBase64String(projectInfo.TempData); |
|
string LayerCfgd = Encoding.Default.GetString(contentArray); |
|
LayerCfg layerInfo = SerializeAPI.DeserializeToObject<LayerCfg>(LayerCfgd); |
|
//string strMxdPath = @"C:\Users\Administrator\Desktop\临时文档\新建文件夹\LatersSymbolToXML.xml"; |
|
//LayerCfg layerInfo = SerializeAPI.DeserializeToObject2<LayerCfg>(strMxdPath); |
|
allLayerInfo = layerInfo; |
|
axMapControl.Map.ClearLayers(); |
|
if (layerInfo != null) |
|
{ |
|
if (layerInfo.LayerType == EnumLayerType.Map) |
|
{ |
|
axMapControl.Map.Name = layerInfo.LayerName; |
|
Bitmap groupImg = new Bitmap(Image.FromFile(System.IO.Path.Combine(Application.StartupPath, @"images\menu", "MxtFile" + ".png")), 22, 16); |
|
//string asd = System.IO.Path.Combine(Application.StartupPath, @"images\menu", "MxdFile" + ".png"); |
|
layerInfo.SymbolImg = groupImg; |
|
} |
|
if (layerInfo.Layers.Count > 0) |
|
{ |
|
ISystemCfg cfg2 = BundleRuntime.Instance.GetFirstOrDefaultService<ISystemCfg>(); |
|
SystemCfg = cfg2.Load(); |
|
if (SystemCfg.JcLayerLoadCfg == null) |
|
{ |
|
SystemCfg.JcLayerLoadCfg = new List<LayerCfg>(); |
|
} |
|
|
|
//重新加载大数据影像 |
|
#region 大数据影像 |
|
LayerCfg tempSJYX = layerInfo.Layers.FirstOrDefault(a => a.LayerName == "影像底图"); |
|
LayerCfg tempSJYXWMTSLayer = null; |
|
List<LayerCfg> SJYXAllItem = null; |
|
if (tempSJYX != null && tempSJYX.GetAllItem() != null) |
|
{ |
|
SJYXAllItem = tempSJYX.GetAllItem(); |
|
if (SJYXAllItem != null) |
|
tempSJYXWMTSLayer = SJYXAllItem.FirstOrDefault(b => b.LayerType == EnumLayerType.WMTSLayer); |
|
} |
|
if (tempSJYX != null && tempSJYX.Layers != null) tempSJYX.Layers.Clear(); |
|
|
|
List<ImageSlicing> keyAndValues = UserLoginHelper.GetAllYXGroupLayer(); |
|
if (keyAndValues != null && keyAndValues.Count > 0) |
|
{ |
|
IGroupLayer groupLayer = Kingo.KMapSDK.Common.CommonAPI.GetGroupLayerByName<IGroupLayer>(MapsManager.Instance.MapService.getAxMapControl().Map, Kingo.KMapSDK.Common.GlobalConfig.Instance.GroupName); |
|
IDataCatalogService _DataCatalog = BundleRuntime.Instance.GetFirstOrDefaultService<IDataCatalogService>(); |
|
if (_DataCatalog == null) return; |
|
if (groupLayer != null) |
|
{ |
|
ILayer parent = MapsManager.Instance.MapService.GetGroupLayer(Kingo.KMapSDK.KMap.Instance.KMapGroupLayer.Name); |
|
if (parent != null) |
|
{ |
|
_DataCatalog.RemoveLayer(parent); |
|
_DataCatalog.UpdateTree(); |
|
MapsManager.Instance.MapService.getAxMapControl().Map.DeleteLayer(Kingo.KMapSDK.KMap.Instance.KMapGroupLayer); |
|
MapsManager.Instance.MapService.getAxMapControl().ActiveView.Refresh(); |
|
} |
|
} |
|
|
|
SystemCfg.SJYXLayerLoadCfg.Clear(); |
|
layerInfo.Layers.Remove(tempSJYX); |
|
//初始化时间轴底图服务 |
|
try |
|
{ |
|
Kingo.KMapSDK.KMap.Instance.InitKMaps(keyAndValues); |
|
//加载时间轴底图服务到地图窗口 |
|
if (Kingo.KMapSDK.KMap.Instance.KMapGroupLayer != null) |
|
{ |
|
IGroupLayer group = Kingo.KMapSDK.KMap.Instance.KMapGroupLayer as IGroupLayer; |
|
ILayerGeneralProperties layerGeneralProperties = group as ILayerGeneralProperties; |
|
layerGeneralProperties.LayerDescription = group.Name; |
|
|
|
if (tempSJYXWMTSLayer != null) |
|
{ |
|
group.MinimumScale = tempSJYXWMTSLayer.MinScale; |
|
group.MaximumScale = tempSJYXWMTSLayer.MaxScale; |
|
if (group is ILayerEffects mLayerEffects) |
|
mLayerEffects.Transparency = (short)tempSJYXWMTSLayer.Transparency; |
|
group.Visible = tempSJYXWMTSLayer.Visible; |
|
tempSJYXWMTSLayer.Data = group; |
|
group.Visible = tempSJYXWMTSLayer.Visible == false ? false : GetParentIsChecked(tempSJYXWMTSLayer); |
|
} |
|
else |
|
group.Visible = false; |
|
//影像底图 第一层级 |
|
LayerCfg GroupLayerInfo = _DataCatalog.AddLayer(group) as LayerCfg; |
|
LayerCfg node = new LayerCfg() |
|
{ |
|
Visible = false, |
|
IsChecked = false, |
|
LayerName = group.Name, |
|
FcPath = UserLoginHelper.GetYXGroupLayerValueByAliasName(group.Name), |
|
LayerType = EnumLayerType.GroupLayer |
|
}; |
|
SystemCfg.SJYXLayerLoadCfg.Add(node); |
|
|
|
Dictionary<ILayer, ILayer> layers = new Dictionary<ILayer, ILayer>(); |
|
if (Kingo.KMapSDK.KMap.Instance.KMapGroupLayer is ICompositeLayer) |
|
{ |
|
layers = GetAllLayerInGroupLayer(Kingo.KMapSDK.KMap.Instance.KMapGroupLayer as ICompositeLayer, Kingo.KMapSDK.KMap.Instance.KMapGroupLayer); |
|
} |
|
else |
|
layers.Add(Kingo.KMapSDK.KMap.Instance.KMapGroupLayer, null); |
|
|
|
// 遍历字典输出键与值 |
|
var fristChilds = layers.Where(a => a.Value == Kingo.KMapSDK.KMap.Instance.KMapGroupLayer).ToList(); |
|
foreach (var fristChild in fristChilds) |
|
{ |
|
LayerCfg fristChildLayerCfg = null; |
|
object tempGroupLayerInfo = GroupLayerInfo; |
|
var secondChilds = layers.Where(a => a.Value == fristChild.Key).ToList(); |
|
if (secondChilds != null && secondChilds.Count > 0) |
|
{ |
|
ILayer fristChildGroupLayer = new GroupLayer() { Name = fristChild.Key.Name }; |
|
ILayerGeneralProperties fristChildLayerGeneralProperties = fristChildGroupLayer as ILayerGeneralProperties; |
|
fristChildLayerGeneralProperties.LayerDescription = fristChild.Key.Name; |
|
|
|
if (tempSJYXWMTSLayer != null) |
|
{ |
|
fristChildGroupLayer.MinimumScale = tempSJYXWMTSLayer.MinScale; |
|
fristChildGroupLayer.MaximumScale = tempSJYXWMTSLayer.MaxScale; |
|
if (fristChildGroupLayer is ILayerEffects mLayerEffectsfristChild) |
|
mLayerEffectsfristChild.Transparency = (short)tempSJYXWMTSLayer.Transparency; |
|
fristChildGroupLayer.Visible = tempSJYXWMTSLayer.Visible; |
|
tempSJYXWMTSLayer.Data = fristChildGroupLayer; |
|
fristChildGroupLayer.Visible = tempSJYXWMTSLayer.Visible == false ? false : GetParentIsChecked(tempSJYXWMTSLayer); |
|
} |
|
else |
|
fristChildGroupLayer.Visible = false; |
|
tempGroupLayerInfo = _DataCatalog.AddLayer(fristChildGroupLayer, GroupLayerInfo); |
|
fristChildLayerCfg = new LayerCfg(node) |
|
{ |
|
Visible = false, |
|
IsChecked = false, |
|
LayerName = fristChild.Key.Name, |
|
FcPath = UserLoginHelper.GetYXGroupLayerValueByAliasName(fristChild.Key.Name), |
|
LayerType = EnumLayerType.WMTSLayer |
|
}; |
|
SystemCfg.SJYXLayerLoadCfg.Add(fristChildLayerCfg); |
|
} |
|
else |
|
{ |
|
if (tempSJYXWMTSLayer != null) |
|
{ |
|
fristChild.Key.MinimumScale = tempSJYXWMTSLayer.MinScale; |
|
fristChild.Key.MaximumScale = tempSJYXWMTSLayer.MaxScale; |
|
if (fristChild.Key is ILayerEffects mLayerEffectsfristChild) |
|
mLayerEffectsfristChild.Transparency = (short)tempSJYXWMTSLayer.Transparency; |
|
fristChild.Key.Visible = tempSJYXWMTSLayer.Visible; |
|
tempSJYXWMTSLayer.Data = fristChild.Key; |
|
fristChild.Key.Visible = tempSJYXWMTSLayer.Visible == false ? false : GetParentIsChecked(tempSJYXWMTSLayer); |
|
} |
|
else |
|
fristChild.Key.Visible = false; |
|
tempGroupLayerInfo = _DataCatalog.AddLayer(fristChild.Key, GroupLayerInfo); |
|
fristChildLayerCfg = new LayerCfg(node) |
|
{ |
|
Visible = false, |
|
IsChecked = false, |
|
LayerName = fristChild.Key.Name, |
|
FcPath = UserLoginHelper.GetYXGroupLayerValueByAliasName(fristChild.Key.Name), |
|
LayerType = EnumLayerType.WMTSLayer |
|
}; |
|
SystemCfg.SJYXLayerLoadCfg.Add(fristChildLayerCfg); |
|
} |
|
|
|
foreach (var secondChild in secondChilds) |
|
{ |
|
if (tempSJYXWMTSLayer != null) |
|
{ |
|
secondChild.Key.MinimumScale = tempSJYXWMTSLayer.MinScale; |
|
secondChild.Key.MaximumScale = tempSJYXWMTSLayer.MaxScale; |
|
if (secondChild.Key is ILayerEffects mLayerEffectssecondChild) |
|
mLayerEffectssecondChild.Transparency = (short)tempSJYXWMTSLayer.Transparency; |
|
secondChild.Key.Visible = tempSJYXWMTSLayer.Visible; |
|
tempSJYXWMTSLayer.Data = secondChild.Key; |
|
secondChild.Key.Visible = tempSJYXWMTSLayer.Visible == false ? false : GetParentIsChecked(tempSJYXWMTSLayer); |
|
} |
|
else |
|
secondChild.Key.Visible = false; |
|
_DataCatalog.AddLayer(secondChild.Key, tempGroupLayerInfo); |
|
LayerCfg secondLayerCfg = new LayerCfg(fristChildLayerCfg) |
|
{ |
|
Visible = false, |
|
IsChecked = false, |
|
LayerName = secondChild.Key.Name, |
|
FcPath = UserLoginHelper.GetYXGroupLayerValueByAliasName(secondChild.Key.Name), |
|
LayerType = EnumLayerType.WMTSLayer |
|
}; |
|
SystemCfg.SJYXLayerLoadCfg.Add(secondLayerCfg); |
|
} |
|
} |
|
layerInfo.Layers.Add(GroupLayerInfo); |
|
tempSJYX = layerInfo.Layers.FirstOrDefault(a => a.LayerName == "影像底图"); |
|
} |
|
} |
|
catch (Exception exce) |
|
{ |
|
LogAPI.Debug("加载大数据影像 异常：" + exce.Message); |
|
LogAPI.Debug("加载大数据影像 异常：" + exce.StackTrace); |
|
} |
|
} |
|
else |
|
{ |
|
layerInfo.Layers.Remove(tempSJYX); |
|
} |
|
#endregion |
|
|
|
layerInfo.Layers.Reverse(); |
|
foreach (var item in layerInfo.Layers) |
|
{ |
|
if (item.LayerName == "影像底图" && tempSJYX != null && tempSJYX.GetAllItem() != null && tempSJYX.GetAllItem().FirstOrDefault(b => b.LayerType == EnumLayerType.WMTSLayer) != null) continue; |
|
IGroupLayer rootGroupLayer = new GroupLayer() { Name = item.LayerName, Visible = item.Visible }; |
|
ILayerGeneralProperties layerGeneralProperties = rootGroupLayer as ILayerGeneralProperties; |
|
layerGeneralProperties.LayerDescription = item.FcName; |
|
LayerCfg GroupLayerInfo = _DataCatalog.AddLayer(rootGroupLayer) as LayerCfg; |
|
item.Symbol = GroupLayerInfo.Symbol; |
|
item.SymbolImg = GroupLayerInfo.SymbolImg; |
|
item.Data = GroupLayerInfo.Data; |
|
LoadLayerToMap(GroupLayerInfo, item.Layers); |
|
} |
|
layerInfo.Layers.Reverse(); |
|
} |
|
if (_DataCatalog != null) |
|
{ |
|
_DataCatalog.CurrentLayers = layerInfo; |
|
_DataCatalog.UpdateTree(); |
|
} |
|
Byte[] bytearr = System.Text.Encoding.Default.GetBytes(SerializeAPI.SerializeToXML<LayerCfg>(layerInfo)); |
|
string strBase64 = Convert.ToBase64String(bytearr); |
|
projectInfo.TempData = strBase64; |
|
projectInfo.Save(); |
|
} |
|
try |
|
{ |
|
time = DateTime.Now; |
|
#region 装载地图 |
|
IWorkspaceAPI wsAPI = new WorkspaceAPI(projectInfo.JCKPath, WorkspaceTypeEnum.GDBFile, true); |
|
ISpatialReference reference = GeoDBAPI.GetGeoDatasetSpatialReference(wsAPI.CurrentWorkspace) ?? GetCurentProjectedCoordinate(projectInfo.PrjFileStr); |
|
if (axMapControl.Map.SpatialReference != reference && reference != null) |
|
{ |
|
axMapControl.Map.SpatialReference = reference; |
|
} |
|
#endregion |
|
if (projectInfo.MapExtent != null && projectInfo.MapExtent.XMax > 0 && projectInfo.MapExtent.YMax > 0 && projectInfo.MapExtent.XMin > 0 && projectInfo.MapExtent.YMin > 0) |
|
{ |
|
IEnvelope env = axMapControl.ActiveView.Extent; |
|
env.XMax = projectInfo.MapExtent.XMax; |
|
env.YMax = projectInfo.MapExtent.YMax; |
|
env.XMin = projectInfo.MapExtent.XMin; |
|
env.YMin = projectInfo.MapExtent.YMin; |
|
axMapControl.ActiveView.Extent = env; |
|
} |
|
//axMapControl.Map = axMapControl.Map.Copy<IMap>(); |
|
} |
|
finally |
|
{ } |
|
SetFolderPath(projectInfo.ProjDir); |
|
|
|
#region 记录最近打开的工程 |
|
//使用接口调用不确定是否为当前工作目录 |
|
string workCatalogPath = SplitWorkCatalogPath(pPrjFile); |
|
string workCatalogPathTemp = workCatalogPath + "\\RecentWorkCatalogRecord.xml"; |
|
XmlDocument docWork = new XmlDocument(); |
|
if (File.Exists(workCatalogPathTemp) == false) |
|
{ |
|
XmlDeclaration dec = docWork.CreateXmlDeclaration("1.0", "utf-8", null); |
|
docWork.AppendChild(dec); |
|
XmlElement projectmessage = docWork.CreateElement("projectmessage"); |
|
docWork.AppendChild(projectmessage); |
|
docWork.Save(workCatalogPathTemp); |
|
} |
|
UpDataFileAttribute(workCatalogPathTemp); |
|
SysConfigsOprator configOp = new SysConfigsOprator(); |
|
//记录不存在,可以加 |
|
if (configOp.JudgeRecentOpenProjectRecordXmlMsgIsExist(workCatalogPathTemp, pPrjFile) == false) |
|
{ |
|
docWork.Load(workCatalogPathTemp); |
|
XmlElement projectrecord = docWork.DocumentElement; |
|
XmlElement project = docWork.CreateElement("project"); |
|
|
|
project.SetAttribute("ProjectPath", pPrjFile); |
|
projectrecord.AppendChild(project); |
|
|
|
project.SetAttribute("LastOpenTime", DateTime.Now.Year + "-" + DateTime.Now.Month + "-" + DateTime.Now.Day + " " + DateTime.Now.Hour + ":" + DateTime.Now.Minute + ":" + DateTime.Now.Second); |
|
projectrecord.AppendChild(project); |
|
|
|
//加上工程唯一标识码---2020-6-12 |
|
string sProjectUniqueID_Now = System.Guid.NewGuid().ToString("N"); |
|
sProjectUniqueID_Now += DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString(); |
|
project.SetAttribute("ProjectUniqueID", sProjectUniqueID_Now); |
|
projectrecord.AppendChild(project); |
|
|
|
project.SetAttribute("ProjType", Platform.Instance.SystemType.ToTrim()); |
|
projectrecord.AppendChild(project); |
|
|
|
docWork.Save(workCatalogPathTemp); |
|
} |
|
else |
|
{ |
|
//更新打开记录的时间 |
|
configOp.UpdateProjectFileOpenTime(workCatalogPathTemp, pPrjFile); |
|
} |
|
#endregion |
|
ProjectOpened?.Invoke(null, new ProjectArgs(projectInfo)); |
|
} |
|
IGeometry geo = null; |
|
geo = AuthorizationVerification.DrawAuthorizationRange(axMapControl.Map.SpatialReference); |
|
if (geo != null && !geo.IsEmpty) |
|
{ |
|
MapsManager.Instance.MapService.DrawGraph(geo, true); |
|
MapsManager.Instance.MapService.Zoom(geo); |
|
DrawBaseGraph(geo, 150, 150, 150); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
MessageHelper.ShowError("加载工程异常：" + ex.Message); |
|
LogAPI.Debug("加载工程异常：" + ex); |
|
} |
|
finally |
|
{ |
|
this.CloseLoading(); |
|
} |
|
} |
|
public ISpatialReference GetCurentProjectedCoordinate(string pPrjFileStr) |
|
{ |
|
try |
|
{ |
|
if (!string.IsNullOrWhiteSpace(pPrjFileStr)) |
|
{ |
|
//创建一个要素集创建一个投影 |
|
ISpatialReferenceFactory pSpatialRefFac = new SpatialReferenceEnvironmentClass(); |
|
ISpatialReference pSpatialReference; |
|
pPrjFileStr = pPrjFileStr.Replace("'", "\""); |
|
pSpatialRefFac.CreateESRISpatialReference(pPrjFileStr, out pSpatialReference, out int s); |
|
return pSpatialReference; |
|
} |
|
return null; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("创建投影坐标系失败：" + ex.Message); |
|
return null; |
|
} |
|
} |
|
|
|
/// <summary> |
|
///为文件夹添加users，everyone，Administrator用户组的完全控制权限 |
|
/// </summary> |
|
/// <param name="dirPath"></param> |
|
static void AddSecurityControll2Folder(string dirPath) |
|
{ |
|
//获取文件夹信息 |
|
DirectoryInfo dir = new DirectoryInfo(dirPath); |
|
//获得该文件夹的所有访问权限 |
|
System.Security.AccessControl.DirectorySecurity dirSecurity = dir.GetAccessControl(AccessControlSections.All); |
|
//设定文件ACL继承 |
|
InheritanceFlags inherits = InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit; |
|
//添加ereryone用户组的访问权限规则 完全控制权限 |
|
FileSystemAccessRule everyoneFileSystemAccessRule = new FileSystemAccessRule("Everyone", FileSystemRights.FullControl, inherits, PropagationFlags.None, AccessControlType.Allow); |
|
//添加Users用户组的访问权限规则 完全控制权限 |
|
FileSystemAccessRule usersFileSystemAccessRule = new FileSystemAccessRule("Users", FileSystemRights.FullControl, inherits, PropagationFlags.None, AccessControlType.Allow); |
|
//添加Administrator用户组的访问权限规则 完全控制权限 |
|
FileSystemAccessRule AdministratorFileSystemAccessRule = new FileSystemAccessRule("Administrator", FileSystemRights.FullControl, inherits, PropagationFlags.None, AccessControlType.Allow); |
|
bool isModified = false; |
|
dirSecurity.ModifyAccessRule(AccessControlModification.Add, everyoneFileSystemAccessRule, out isModified); |
|
dirSecurity.ModifyAccessRule(AccessControlModification.Add, usersFileSystemAccessRule, out isModified); |
|
//设置访问权限 |
|
dir.SetAccessControl(dirSecurity); |
|
} |
|
|
|
/// <summary> |
|
/// 修改文件的可读写 |
|
/// </summary> |
|
/// <param name="T_Path"></param> |
|
private void UpDataFileAttribute(string T_Path) |
|
{ |
|
try |
|
{ |
|
DirectoryInfo dirInfo = new DirectoryInfo(T_Path); |
|
dirInfo.Attributes = FileAttributes.Normal | FileAttributes.Directory; |
|
FileInfo fileInfo = new FileInfo(T_Path); |
|
if (fileInfo.IsReadOnly) |
|
{ |
|
File.SetAttributes(T_Path, FileAttributes.Normal); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex.Message); |
|
} |
|
} |
|
/// <summary> |
|
/// 根据工程文件路径获取工作目录路径 |
|
/// </summary> |
|
/// <param name="pPrjFile"></param> |
|
/// <returns></returns> |
|
public string SplitWorkCatalogPath(string pPrjFile) |
|
{ |
|
string TempPath = string.Empty; |
|
string pathshba = System.IO.Path.GetFileName(pPrjFile); |
|
//单图斑建库三套系统历史工程记录 |
|
if ((pPrjFile.Contains("DTBZJProject") && pathshba.Equals("单图斑质检.KBG")) || (pPrjFile.Contains("DTBProject") && pathshba.Equals("单图斑建库.KBG")) || (pPrjFile.Contains("YCLProject") && pathshba.Equals("图斑预处理.KBG"))) |
|
{ |
|
for (int i = 0; i < pPrjFile.Split('\\').Length - 1; i++) |
|
{ |
|
TempPath += pPrjFile.Split('\\')[i] + "\\"; |
|
} |
|
} |
|
else if (Path.GetFileName(pPrjFile).EndsWith(".KBG"))//建库软件向上循环获取工作目录 |
|
{ |
|
for (int i = 0; i < pPrjFile.Split('\\').Length - 4; i++) |
|
{ |
|
TempPath += pPrjFile.Split('\\')[i] + "\\"; |
|
} |
|
} |
|
else if (Path.GetFileName(pPrjFile) == "工作目录") |
|
{ |
|
for (int i = 0; i < pPrjFile.Split('\\').Length - 2; i++) |
|
{ |
|
TempPath += pPrjFile.Split('\\')[i] + "\\"; |
|
} |
|
} |
|
return TempPath.TrimEnd('\\'); |
|
} |
|
private IGroupLayer GetGroupLayer(IMap map, string Description, bool IsClear = true) |
|
{ |
|
try |
|
{ |
|
IGroupLayer pgpLayer = null; |
|
if (map != null && !string.IsNullOrEmpty(Description)) |
|
{ |
|
for (int i = 0; i < map.LayerCount; i++) |
|
{ |
|
if (map.get_Layer(i) is IGroupLayer) |
|
{ |
|
ILayerGeneralProperties lp = map.get_Layer(i) as ILayerGeneralProperties; |
|
if (lp != null && lp.LayerDescription.ToUpper().Equals(Description.ToUpper())) |
|
{ |
|
pgpLayer = map.get_Layer(i) as IGroupLayer; |
|
//if (IsClear) |
|
// pgpLayer.Clear(); |
|
return pgpLayer; |
|
} |
|
ICompositeLayer pComLayer = map.get_Layer(i) as ICompositeLayer; |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
if (pComLayer.get_Layer(j) is IGroupLayer) |
|
{ |
|
ILayerGeneralProperties lgp = pComLayer.get_Layer(j) as ILayerGeneralProperties; |
|
if (lgp != null && lgp.LayerDescription.ToUpper().Equals(Description.ToUpper())) |
|
{ |
|
pgpLayer = pComLayer.get_Layer(j) as IGroupLayer; |
|
//if (IsClear) |
|
// pgpLayer.Clear(); |
|
return pgpLayer; |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
return pgpLayer; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
public void LoadProjectByMxd(string filePath) |
|
{ |
|
try |
|
{ |
|
if (true == string.IsNullOrEmpty(filePath) || false == File.Exists(filePath)) |
|
{ |
|
return; |
|
} |
|
|
|
axMapControl.CurrentTool = null; |
|
projectInfo = new ProjectInfo(); |
|
projectInfo.ProjName = System.IO.Path.GetFileNameWithoutExtension(filePath); |
|
projectInfo.ProjSuffix = System.IO.Path.GetExtension(filePath); |
|
projectInfo.ProjDir = System.IO.Path.GetDirectoryName(filePath); |
|
(MapsManager.Instance.CurrProjectInfo as ProjectInfo).ProjName = System.IO.Path.GetFileNameWithoutExtension(filePath); |
|
(MapsManager.Instance.CurrProjectInfo as ProjectInfo).ProjSuffix = System.IO.Path.GetExtension(filePath); |
|
(MapsManager.Instance.CurrProjectInfo as ProjectInfo).ProjDir = System.IO.Path.GetDirectoryName(filePath); |
|
|
|
ESRI.ArcGIS.Carto.IMapDocument mDoc = new ESRI.ArcGIS.Carto.MapDocumentClass(); |
|
mDoc.Open(filePath); |
|
|
|
ESRI.ArcGIS.Carto.IMap map = mDoc.get_Map(0); |
|
if (map == null) |
|
return; |
|
map.Name = projectInfo.ProjName; |
|
ISpatialReference reference = GeoDBAPI.GetGeoDatasetSpatialReference(GetDefaultWorkspace(map)); |
|
if (map.SpatialReference != reference && reference != null) |
|
{ |
|
map.SpatialReference = reference; |
|
} |
|
IActiveView view = (IActiveView)map; |
|
mDoc.SetActiveView(view); |
|
CtlsSynchronizer.ReplaceMap(map); |
|
axMapControl.DocumentFilename = filePath; |
|
mDoc.Close(); |
|
ProjectClosed?.Invoke(null, null); |
|
} |
|
catch (Exception ex) |
|
{ |
|
|
|
throw ex; |
|
} |
|
} |
|
|
|
public void SetFolderPath(string folderPath) |
|
{ |
|
m_FolderPath = folderPath; |
|
Platform.Instance.ViewManager.SetFilePath(m_FolderPath); |
|
} |
|
|
|
public string GetFolderPath() |
|
{ |
|
return m_FolderPath; |
|
} |
|
public bool DeleteTheDir(string strPath) |
|
{ |
|
try |
|
{ |
|
strPath = @strPath.Trim(); |
|
if (Directory.Exists(strPath)) |
|
{ |
|
string[] strDirs = Directory.GetDirectories(strPath); |
|
string[] strFiles = Directory.GetFiles(strPath); |
|
|
|
int iCountDirs = strDirs.Count(); |
|
int iFileDirs = strFiles.Count(); |
|
|
|
foreach (string strFile in strFiles) |
|
{ |
|
File.Delete(strFile); |
|
} |
|
foreach (string strdir in strDirs) |
|
{ |
|
Directory.Delete(strdir, true); |
|
} |
|
//LogAPI.Debug("清空变更统计信息文件夹 。文件夹数量=" + iCountDirs + " ; 文件数量=" + iFileDirs + " ; "); |
|
} |
|
return true; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("清空文件目录(" + strPath + ") 时失败，异常原因: " + ex + " ; "); |
|
return false; |
|
} |
|
} |
|
|
|
public void CloseProject() |
|
{ |
|
IMapDocument mDoc = new MapDocumentClass(); |
|
try |
|
{ |
|
EngineEditor editor = new EngineEditorClass(); |
|
#region 修改在编辑状态时，快捷键保存工程不提示信息；修改人：白明雅；修改时间：2018-09-04 |
|
if (editor.EditState == esriEngineEditState.esriEngineStateEditing) |
|
{ |
|
MessageHelper.ShowTips("当前工程正处于编辑状态，保存之前请先结束编辑!"); |
|
return; |
|
} |
|
#endregion |
|
if (projectInfo != null) |
|
SaveProject(); |
|
else |
|
return; |
|
projectInfo = null; |
|
axMapControl.Map.Name = "地图文档"; |
|
axMapControl.ClearLayers(); |
|
axMapControl.CurrentTool = null; |
|
ProjectClosed?.Invoke(null, null); |
|
axMapControl.ActiveView.GraphicsContainer.DeleteAllElements(); |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
finally |
|
{ |
|
mDoc.Close(); |
|
} |
|
} |
|
|
|
public void FlashShape(IMapControlDefault mapControl, IGeometry geo, int nflashes = 3, int flashInterval = 300) |
|
{ |
|
try |
|
{ |
|
IRgbColor pRgbColor = new RgbColorClass(); |
|
pRgbColor.Red = 0; |
|
pRgbColor.Green = 105; |
|
pRgbColor.Blue = 0; |
|
ILineSymbol pLineSymbol = new SimpleLineSymbolClass(); |
|
pLineSymbol.Color = Converter.ToRGBColor(Color.Black) as IColor; |
|
pLineSymbol.Width = 5; |
|
ISimpleFillSymbol pSimpleFillSymbol = new SimpleFillSymbolClass(); |
|
pSimpleFillSymbol.Color = pRgbColor; |
|
pSimpleFillSymbol.Outline = pLineSymbol; |
|
|
|
ISimpleLineSymbol pSimpleLineSymbol = new SimpleLineSymbolClass(); |
|
pSimpleLineSymbol.Color = pRgbColor; |
|
pSimpleLineSymbol.Width = 8; |
|
|
|
ISimpleMarkerSymbol pSimpleMarkerSymbol = new SimpleMarkerSymbolClass(); |
|
pSimpleMarkerSymbol.Color = pRgbColor; |
|
pSimpleMarkerSymbol.Size = 14; |
|
pSimpleMarkerSymbol.Outline = true; |
|
pSimpleMarkerSymbol.OutlineSize = 2; |
|
pSimpleMarkerSymbol.OutlineColor = Converter.ToRGBColor(Color.Black) as IColor; |
|
|
|
if (geo.GeometryType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint) |
|
mapControl.FlashShape(geo, nflashes, flashInterval, pSimpleMarkerSymbol); |
|
else if (geo.GeometryType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline) |
|
mapControl.FlashShape(geo, nflashes, flashInterval, pSimpleLineSymbol); |
|
else if (geo.GeometryType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon) |
|
mapControl.FlashShape(geo, nflashes, flashInterval, pSimpleFillSymbol); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("执行 FlashShape 时异常，异常信息如下："); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("执行 FlashShape 时异常信息结束"); |
|
|
|
MessageHelper.ShowError("操作异常！异常信息：" + ex.Message); |
|
//LogAPI.Debug(ex); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 根据名称获取当前工程中的图层 |
|
/// </summary> |
|
/// <param name="pName"></param> |
|
/// <returns></returns> |
|
public IFeatureLayer GetFeatureLayerByName(string pName) |
|
{ |
|
IFeatureLayer result = null; |
|
try |
|
{ |
|
IEnumLayer enumlayer = axMapControl.Map.Layers; |
|
ILayer layer = null; |
|
while ((layer = enumlayer.Next()) != null) |
|
{ |
|
if (!(layer is IFeatureLayer)) |
|
continue; |
|
IFeatureLayer featureLayer = layer as IFeatureLayer; |
|
if (featureLayer.FeatureClass == null || (featureLayer as IDataset) == null || (featureLayer as IDataset).Workspace == null) |
|
continue; |
|
if (featureLayer is IDataset && GetClassShortName(featureLayer as IDataset).ToUpper() == pName.ToUpper()) |
|
{ |
|
result = featureLayer; |
|
break; |
|
} |
|
|
|
//if (featureLayer is IDataset && GetClassShortName(featureLayer as IDataset).ToUpper() == pName.ToUpper() && (featureLayer as IDataset).Workspace.PathName == Env.Instance.Project.GetProjMDBPath()) |
|
//{ |
|
// result = featureLayer; |
|
// break; |
|
//} |
|
//if (IsRemoteDatabase(featureLayer)) |
|
//{ |
|
// if (featureLayer is IDataset && GetClassShortName(featureLayer as IDataset).ToUpper() == pName.ToUpper()) |
|
// result = featureLayer; |
|
//} |
|
//else |
|
//{ |
|
// if (featureLayer is IDataset && GetClassShortName(featureLayer as IDataset).ToUpper() == pName.ToUpper() && (featureLayer as IDataset).Workspace.PathName == Env.Instance.Project.GetProjMDBPath()) |
|
// result = featureLayer; |
|
//} |
|
} |
|
return result; |
|
} |
|
catch |
|
{ |
|
throw; |
|
} |
|
} |
|
|
|
public IFeatureLayer GetFeatureLayerByLayerName(string layerName) |
|
{ |
|
IFeatureLayer result = null; |
|
try |
|
{ |
|
IEnumLayer enumlayer = axMapControl.Map.Layers; |
|
ILayer layer = null; |
|
while ((layer = enumlayer.Next()) != null) |
|
{ |
|
if (!(layer is IFeatureLayer)) |
|
continue; |
|
IFeatureLayer featureLayer = layer as IFeatureLayer; |
|
|
|
if (featureLayer.Name.ToUpper().Equals(layerName)) |
|
{ |
|
result = featureLayer; |
|
break; |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
public IRasterLayer GetRasterLayerByLayerName(string layerName) |
|
{ |
|
IRasterLayer result = null; |
|
try |
|
{ |
|
IEnumLayer enumlayer = axMapControl.Map.Layers; |
|
ILayer layer = null; |
|
while ((layer = enumlayer.Next()) != null) |
|
{ |
|
if (!(layer is IRasterLayer)) |
|
continue; |
|
IRasterLayer rasterLayer = layer as IRasterLayer; |
|
|
|
if (rasterLayer.Name.ToUpper().Equals(layerName)) |
|
{ |
|
result = rasterLayer; |
|
break; |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
|
|
public IRasterLayer GetRasterLayerByLayerName(string groupName, string layerName) |
|
{ |
|
IRasterLayer result = null; |
|
try |
|
{ |
|
IEnumLayer enumlayer = axMapControl.Map.Layers; |
|
ILayer layer = null; |
|
while ((layer = enumlayer.Next()) != null) |
|
{ |
|
|
|
if (layer is IGroupLayer) |
|
{ |
|
IGroupLayer grlayer = layer as IGroupLayer; |
|
if (grlayer.Name.Equals(groupName)) |
|
{ |
|
ICompositeLayer pComLayer = layer as ICompositeLayer; |
|
for (int j = 0; j < pComLayer.Count; j++) |
|
{ |
|
ILayer newLayer = pComLayer.get_Layer(j); |
|
|
|
if (!(newLayer is IRasterLayer)) |
|
continue; |
|
IRasterLayer rasterLayer = newLayer as IRasterLayer; |
|
if (rasterLayer.Name.ToUpper().Equals(layerName.ToUpper())) |
|
{ |
|
result = rasterLayer; |
|
break; |
|
} |
|
} |
|
|
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
return result; |
|
} |
|
|
|
/// <summary> |
|
/// 通过图层名称获取图层 |
|
/// </summary> |
|
/// <param name="pName">图层名称</param> |
|
/// <returns></returns> |
|
public IFeatureClass GetFeatureClassByName(string pName) |
|
{ |
|
IFeatureClass result = null; |
|
try |
|
{ |
|
IEnumLayer enumlayer = axMapControl.Map.Layers; |
|
ILayer layer = null; |
|
while ((layer = enumlayer.Next()) != null) |
|
{ |
|
if (!(layer is IFeatureLayer)) |
|
continue; |
|
IFeatureLayer featureLayer = layer as IFeatureLayer; |
|
if (featureLayer.FeatureClass == null || (featureLayer as IDataset) == null || (featureLayer as IDataset).Workspace == null) |
|
continue; |
|
if (featureLayer is IDataset && GetClassShortName(featureLayer as IDataset).ToUpper() == pName.ToUpper()) |
|
result = featureLayer.FeatureClass; |
|
//if (featureLayer is IDataset && GetClassShortName(featureLayer as IDataset).ToUpper() == pName.ToUpper() && (featureLayer as IDataset).Workspace.PathName == Env.Instance.Project.GetProjMDBPath()) |
|
//{ |
|
// result = featureLayer.FeatureClass; |
|
// break; |
|
//} |
|
//if (IsRemoteDatabase(featureLayer)) |
|
//{ |
|
// if (featureLayer is IDataset && GetClassShortName(featureLayer as IDataset).ToUpper() == pName.ToUpper()) |
|
// result = featureLayer.FeatureClass; |
|
//} |
|
//else |
|
//{ |
|
// if (featureLayer is IDataset && GetClassShortName(featureLayer as IDataset).ToUpper() == pName.ToUpper() && (featureLayer as IDataset).Workspace.PathName == Env.Instance.Project.GetProjMDBPath()) |
|
// result = featureLayer.FeatureClass; |
|
//} |
|
} |
|
return result; |
|
} |
|
catch |
|
{ |
|
throw; |
|
} |
|
} |
|
|
|
public void SelectFeature(string layerName, string OIDs, bool IsMoveToCenter = true) |
|
{ |
|
List<IFeature> featureList = null; |
|
try |
|
{ |
|
IMapControlDefault mapControl = Hook as IMapControlDefault; |
|
string[] oidArr = OIDs.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); |
|
ILayer layer = GetFeatureLayerByName(layerName) != null ? GetFeatureLayerByName(layerName) : GetFeatureLayerByLayerName(layerName);//GetLayerByTableName(Env.Instance.KMap.GetMap(), layerName); |
|
if (!(layer is IFeatureLayer)) |
|
{ |
|
return; |
|
} |
|
featureList = new List<IFeature>(); |
|
//ClearFeatureSelection(mapControl); |
|
ISelectionSet pSelectionSetes = (layer as IFeatureSelection).SelectionSet; |
|
if (pSelectionSetes.Count > 0) |
|
{ |
|
int unSeleID = pSelectionSetes.IDs.Next(); |
|
pSelectionSetes.RemoveList(pSelectionSetes.Count, ref unSeleID); |
|
mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, featureList, mapControl.ActiveView.Extent); |
|
} |
|
foreach (string oid in oidArr) |
|
{ |
|
IFeature feature = (layer as IFeatureLayer).FeatureClass.GetFeature(Convert.ToInt32(oid)); |
|
if (feature != null && feature.Shape != null && !feature.Shape.IsEmpty) |
|
{ |
|
featureList.Add(feature); |
|
(Hook as IMapControlDefault).Map.SelectFeature(layer, feature); |
|
} |
|
} |
|
if (IsMoveToCenter && featureList.Count != 0) |
|
{ |
|
MoveToCenter(featureList); |
|
} |
|
if (featureList.Count != 0) |
|
mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, featureList, mapControl.ActiveView.Extent); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug($"{layerName}图斑{OIDs}高亮显示失败：" + ex); |
|
throw ex; |
|
} |
|
finally |
|
{ |
|
if (featureList != null) |
|
{ |
|
featureList.Clear(); |
|
} |
|
} |
|
} |
|
|
|
public IElement DrawGraph(ESRI.ArcGIS.Geometry.IGeometry geoDraw, bool pIsDel = true, int R = 255, int G = 0, int B = 0) |
|
{ |
|
try |
|
{ |
|
IElement result = null; |
|
IGraphicsContainer iGraphicsContainer = null; |
|
IElement CameraPointElm = null; |
|
while ((CameraPointElm = axMapControl.ActiveView.GraphicsContainer.Next()) != null) |
|
{ |
|
if ((CameraPointElm as IElementProperties).Name == "TempElem") |
|
break; |
|
} |
|
if (CameraPointElm == null) |
|
{ |
|
CameraPointElm = new GroupElementClass(); |
|
(CameraPointElm as IElementProperties).Name = "TempElem"; |
|
(Hook as IMapControlDefault).ActiveView.GraphicsContainer.AddElement(CameraPointElm, 0); |
|
} |
|
if (pIsDel == true) |
|
{ |
|
////替换Env改动 |
|
////IGraphicsContainer graphics = Env.Instance.KMap.HookHelper.ActiveView.GraphicsContainer; |
|
//IGraphicsContainer graphics = (Hook as IMapControlDefault).ActiveView.GraphicsContainer; |
|
//graphics.DeleteAllElements(); |
|
(CameraPointElm as IGroupElement).ClearElements(); |
|
} |
|
if (geoDraw == null) return null; |
|
|
|
//替换Env改动---无用 |
|
//IMapControl2 axMapDraw = Env.Instance.KMap.HookHelper.Hook as IMapControl2; |
|
|
|
// 获取IRGBColor接口 |
|
IRgbColor color = new RgbColor(); |
|
// 设置颜色属性 |
|
color.Red = R; |
|
color.Green = G; |
|
color.Blue = B; |
|
switch (geoDraw.GeometryType) |
|
{ |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint: |
|
result = new MarkerElementClass(); |
|
IMarkerSymbol symbol = new SimpleMarkerSymbolClass(); |
|
symbol.Color = color; |
|
symbol.Size = 10; |
|
(result as IMarkerElement).Symbol = symbol; |
|
result.Geometry = geoDraw; |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon: |
|
result = new PolygonElement() { Opacity = 40 }; |
|
// 获取ILine符号接口 |
|
ILineSymbol lineSymbol = new SimpleLineSymbol(); |
|
// 设置线符号属 |
|
lineSymbol.Width = 2; |
|
ISimpleFillSymbol simpleFillSymbol = new SimpleFillSymbolClass(); |
|
simpleFillSymbol.Color = color; |
|
IRgbColor colorLine = new RgbColor(); |
|
colorLine.Red = 255; |
|
colorLine.Green = 0; |
|
colorLine.Blue = 0; |
|
lineSymbol.Color = colorLine; |
|
// 设置填充符号属性 |
|
simpleFillSymbol.Outline = lineSymbol; |
|
simpleFillSymbol.Style = ESRI.ArcGIS.Display.esriSimpleFillStyle.esriSFSCross;//esriSimpleFillStyle.esriSFSSolid; |
|
(result as IFillShapeElement).Symbol = simpleFillSymbol; |
|
result.Geometry = geoDraw; |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline: |
|
result = new LineElementClass(); |
|
// 获取ILine符号接口 |
|
ILineSymbol outline = new SimpleLineSymbol(); |
|
// 设置线符号属 |
|
outline.Width = 3; |
|
outline.Color = color; |
|
(outline as SimpleLineSymbol).Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSSolid; |
|
(result as ILineElement).Symbol = outline; |
|
result.Geometry = geoDraw; |
|
break; |
|
default: |
|
break; |
|
} |
|
if (!pIsDel) |
|
{ |
|
result.Locked = true; |
|
} |
|
|
|
//替换Env改动 |
|
//Env.Instance.KMap.HookHelper.ActiveView.GraphicsContainer.AddElement(result, 0); |
|
//(Hook as IMapControlDefault).ActiveView.GraphicsContainer.AddElement(result, 0); |
|
(CameraPointElm as IGroupElement).AddElement(result); |
|
|
|
if (iGraphicsContainer != null) |
|
{ |
|
iGraphicsContainer.AddElement(result, 0); |
|
} |
|
|
|
return result; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("执行DrawGraph方法时异常：" + ex); |
|
return null; |
|
} |
|
} |
|
|
|
|
|
public IElement DrawBaseGraph(ESRI.ArcGIS.Geometry.IGeometry geoDraw, int R = 255, int G = 0, int B = 0) |
|
{ |
|
try |
|
{ |
|
IElement result = null; |
|
IGraphicsContainer iGraphicsContainer = null; |
|
|
|
|
|
IElement CameraPointElm = null; // axMapControl.ActiveView.GraphicsContainer.Next(); |
|
while ((CameraPointElm = axMapControl.ActiveView.GraphicsContainer.Next()) != null) |
|
{ |
|
if ((CameraPointElm as IElementProperties).Name == "BaseElement") |
|
break; |
|
} |
|
if (CameraPointElm == null) |
|
{ |
|
CameraPointElm = new GroupElementClass(); |
|
(CameraPointElm as IElementProperties).Name = "BaseElement"; |
|
(Hook as IMapControlDefault).ActiveView.GraphicsContainer.AddElement(CameraPointElm, 2); |
|
} |
|
(CameraPointElm as IGroupElement).ClearElements(); |
|
if (geoDraw == null) return null; |
|
|
|
//替换Env改动---无用 |
|
//IMapControl2 axMapDraw = Env.Instance.KMap.HookHelper.Hook as IMapControl2; |
|
|
|
// 获取IRGBColor接口 |
|
IRgbColor color = new RgbColor(); |
|
// 设置颜色属性 |
|
color.Red = R; |
|
color.Green = G; |
|
color.Blue = B; |
|
switch (geoDraw.GeometryType) |
|
{ |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint: |
|
result = new MarkerElementClass(); |
|
IMarkerSymbol symbol = new SimpleMarkerSymbolClass(); |
|
symbol.Color = color; |
|
symbol.Size = 10; |
|
(result as IMarkerElement).Symbol = symbol; |
|
result.Geometry = geoDraw; |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon: |
|
result = new PolygonElement() { Opacity = 100 }; |
|
// 获取ILine符号接口 |
|
ILineSymbol lineSymbol = new SimpleLineSymbol(); |
|
// 设置线符号属 |
|
lineSymbol.Width = 2; |
|
ISimpleFillSymbol simpleFillSymbol = new SimpleFillSymbolClass(); |
|
simpleFillSymbol.Color = color; |
|
IRgbColor colorLine = new RgbColor(); |
|
colorLine.Red = 0; |
|
colorLine.Green = 0; |
|
colorLine.Blue = 0; |
|
lineSymbol.Color = colorLine; |
|
// 设置填充符号属性 |
|
simpleFillSymbol.Outline = lineSymbol; |
|
simpleFillSymbol.Style = ESRI.ArcGIS.Display.esriSimpleFillStyle.esriSFSSolid;//esriSimpleFillStyle.esriSFSSolid; |
|
(result as IFillShapeElement).Symbol = simpleFillSymbol; |
|
result.Geometry = geoDraw; |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline: |
|
result = new LineElementClass(); |
|
// 获取ILine符号接口 |
|
ILineSymbol outline = new SimpleLineSymbol(); |
|
// 设置线符号属 |
|
outline.Width = 3; |
|
outline.Color = color; |
|
(outline as SimpleLineSymbol).Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSSolid; |
|
(result as ILineElement).Symbol = outline; |
|
result.Geometry = geoDraw; |
|
break; |
|
default: |
|
break; |
|
} |
|
(CameraPointElm as IGroupElement).AddElement(result); |
|
|
|
if (iGraphicsContainer != null) |
|
{ |
|
iGraphicsContainer.AddElement(result, 0); |
|
} |
|
|
|
axMapControl.ActiveView.Refresh(); |
|
return result; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("执行DrawGraph方法时异常：" + ex); |
|
return null; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 获取特定样式的图形元素 |
|
/// </summary> |
|
/// <param name="geoDraw"></param> |
|
/// <param name="R"></param> |
|
/// <param name="G"></param> |
|
/// <param name="B"></param> |
|
/// <returns></returns> |
|
public IElement GetGraphicsElement(ESRI.ArcGIS.Geometry.IGeometry geoDraw, int R = 255, int G = 0, int B = 0) |
|
{ |
|
IElement result = null; |
|
try |
|
{ |
|
if (geoDraw == null) |
|
{ |
|
return null; |
|
} |
|
|
|
IRgbColor color = new RgbColor();//获取IRGBColor接口,并设置颜色属性 |
|
color.Red = R; |
|
color.Green = G; |
|
color.Blue = B; |
|
|
|
switch (geoDraw.GeometryType) |
|
{ |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint: |
|
result = new MarkerElementClass(); |
|
IMarkerSymbol symbol = new SimpleMarkerSymbolClass(); |
|
symbol.Color = color; |
|
symbol.Size = 10; |
|
(result as IMarkerElement).Symbol = symbol; |
|
result.Geometry = geoDraw; |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline: |
|
result = new LineElementClass(); |
|
ILineSymbol outline = new SimpleLineSymbol();//获取ILine符号接口,并设置线符号属 |
|
outline.Width = 3; |
|
outline.Color = color; |
|
(outline as SimpleLineSymbol).Style = ESRI.ArcGIS.Display.esriSimpleLineStyle.esriSLSSolid; |
|
(result as ILineElement).Symbol = outline; |
|
result.Geometry = geoDraw; |
|
break; |
|
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon: |
|
result = new PolygonElement() { Opacity = 40 }; |
|
|
|
IRgbColor colorLine = new RgbColor(); |
|
colorLine.Red = 255; |
|
colorLine.Green = 0; |
|
colorLine.Blue = 0; |
|
|
|
ILineSymbol lineSymbol = new SimpleLineSymbol();//获取ILine符号接口,并设置线符号属性 |
|
lineSymbol.Color = colorLine; |
|
lineSymbol.Width = 5; |
|
|
|
ISimpleFillSymbol simpleFillSymbol = new SimpleFillSymbolClass(); |
|
simpleFillSymbol.Color = color; |
|
simpleFillSymbol.Outline = lineSymbol;//设置填充符号属性 |
|
//simpleFillSymbol.Outline = new SimpleLineSymbol() { Color = new RgbColor() { Red = 255, Green = 0, Blue = 0 }, Width = 5 };//设置填充符号属性 |
|
simpleFillSymbol.Style = ESRI.ArcGIS.Display.esriSimpleFillStyle.esriSFSCross;//esriSimpleFillStyle.esriSFSSolid; |
|
(result as IFillShapeElement).Symbol = simpleFillSymbol; |
|
result.Geometry = geoDraw; |
|
break; |
|
default: |
|
break; |
|
} |
|
|
|
return result; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("获取特定样式的图形元素 时失败,异常原因: " + ex + " ; "); |
|
return null; |
|
} |
|
} |
|
|
|
public void Zoom(ESRI.ArcGIS.Geometry.IGeometry geo) |
|
{ |
|
try |
|
{ |
|
if (geo == null) return; |
|
//替换Env改动 |
|
//-----------解决问题图斑处理工具查出的问题图斑双击定位异常，原因axmap为空 |
|
//IMap map = Env.Instance.KMap.HookHelper.FocusMap; |
|
IMap map = (Hook as IMapControlDefault).Map; |
|
|
|
IActiveView axMap = map as IActiveView; |
|
//------------------------------------ |
|
IEnvelope NewExtent = geo.Envelope; |
|
if (geo.Envelope.Width <= 0 || geo.Envelope.Height <= 0) |
|
{ |
|
NewExtent.XMax = geo.Envelope.XMax + 800 / 2; |
|
NewExtent.XMin = geo.Envelope.XMin - 800 / 2; |
|
NewExtent.YMax = geo.Envelope.YMax + 500 / 2; |
|
NewExtent.YMin = geo.Envelope.YMin - 500 / 2; |
|
} |
|
else |
|
{ |
|
NewExtent.XMax = geo.Envelope.XMax + geo.Envelope.Width / 2; |
|
NewExtent.YMax = geo.Envelope.YMax + geo.Envelope.Height / 2; |
|
NewExtent.XMin = geo.Envelope.XMin - geo.Envelope.Width / 2; |
|
NewExtent.YMin = geo.Envelope.YMin - geo.Envelope.Height / 2; |
|
} |
|
axMap.Extent = NewExtent; |
|
try |
|
{ |
|
if (axMap.FocusMap.MapScale < 2) |
|
axMap.FocusMap.MapScale = 2; |
|
} |
|
catch { } |
|
axMap.PartialRefresh(esriViewDrawPhase.esriViewAll, geo, axMap.Extent); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("执行Zoom方法时异常:" + ex); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 清除选中的要素 |
|
/// </summary> |
|
/// <param name="mapControl"></param> |
|
/// <param name="layerName"></param> |
|
public void ClearFeatureSelection(IMapControlDefault mapControl, string layerName = "") |
|
{ |
|
try |
|
{ |
|
if (!string.IsNullOrEmpty(layerName)) |
|
{ |
|
ILayer clearLy = GetFeatureLayerByName(layerName); |
|
|
|
if (!(clearLy is IFeatureLayer)) return; |
|
IFeatureSelection pFeatureSelection = clearLy as IFeatureSelection; |
|
mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, pFeatureSelection, null); |
|
pFeatureSelection.Clear(); |
|
mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, pFeatureSelection, null); |
|
} |
|
else |
|
{ |
|
ISelection pSelection = mapControl.Map.FeatureSelection as ISelection; |
|
mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, pSelection, null); |
|
|
|
ControlsClearSelectionCommand cmd = new ControlsClearSelectionCommandClass(); |
|
cmd.OnCreate(mapControl); |
|
cmd.OnClick(); |
|
|
|
mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
MessageHelper.ShowError("操作异常！异常信息：" + ex.Message); |
|
LogAPI.Debug(ex); |
|
} |
|
} |
|
|
|
public object GetProjectInfo() |
|
{ |
|
return projectInfo; |
|
} |
|
|
|
public void SetCustomProperty(object pProperty) |
|
{ |
|
if (axMapControl != null) |
|
axMapControl.CustomProperty = pProperty; |
|
} |
|
|
|
public string GetLayerPathByLayer(ILayer pLayer) |
|
{ |
|
if (pLayer is IFeatureLayer) |
|
{ |
|
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer; |
|
|
|
if (pFeatureLayer.FeatureClass == null || (pFeatureLayer as IDataset) == null || (pFeatureLayer as IDataset).Workspace == null) |
|
return ""; |
|
FeatureClass fc = pFeatureLayer.FeatureClass as FeatureClass; |
|
if (pFeatureLayer.FeatureClass.FeatureDataset != null) |
|
{ |
|
//if (fc.Workspace.WorkspaceFactory.WorkspaceType == esriWorkspaceType.esriRemoteDatabaseWorkspace |
|
// && (string.IsNullOrWhiteSpace(fc.Workspace.PathName) || !System.IO.File.Exists(fc.Workspace.PathName))) |
|
//{ |
|
// return System.IO.Path.Combine(fc.Workspace.PathName, pFeatureLayer.FeatureClass.FeatureDataset.BrowseName, fc.BrowseName); |
|
//} |
|
return global::System.IO.Path.Combine(fc.Workspace.PathName, pFeatureLayer.FeatureClass.FeatureDataset.BrowseName, fc.BrowseName); |
|
} |
|
else |
|
{ |
|
return global::System.IO.Path.Combine(fc.Workspace.PathName, fc.BrowseName); |
|
} |
|
////return (pFeatureLayer as IDataset).Workspace.PathName; |
|
|
|
} |
|
return ""; |
|
} |
|
|
|
|
|
public List<T> GetAllLayerInMap<T>() |
|
{ |
|
try |
|
{ |
|
List<T> allLayers = new List<T>(); |
|
for (int i = 0; i < axMapControl.Map.LayerCount; i++) |
|
{ |
|
ILayer layer = axMapControl.Map.get_Layer(i); |
|
if (layer is ICompositeLayer) |
|
{ |
|
List<T> list = GetAllLayerInGroupLayer<T>(layer as ICompositeLayer); |
|
allLayers.AddRange(list); |
|
} |
|
else |
|
{ |
|
if (layer is T) |
|
{ |
|
allLayers.Add((T)layer); |
|
} |
|
} |
|
} |
|
return allLayers; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
public List<IGroupLayer> GetAllRasterGroupLayerInMap<T>() |
|
{ |
|
try |
|
{ |
|
List<IGroupLayer> allLayers = new List<IGroupLayer>(); |
|
for (int i = 0; i < axMapControl.Map.LayerCount; i++) |
|
{ |
|
ILayer layer = axMapControl.Map.get_Layer(i); |
|
if (layer is ICompositeLayer) |
|
{ |
|
List<T> list = GetAllLayerInGroupLayer<T>(layer as ICompositeLayer); |
|
if (list.Count > 0) |
|
allLayers.Add(layer as IGroupLayer); |
|
} |
|
else |
|
{ |
|
//if (layer is T) |
|
//{ |
|
// allLayers.Add((T)layer); |
|
//} |
|
} |
|
} |
|
return allLayers; |
|
} |
|
catch (Exception ex) |
|
{ |
|
throw ex; |
|
} |
|
} |
|
|
|
public AxMapControl getAxMapControl() |
|
{ |
|
//throw new NotImplementedException(); |
|
return this.axMapControl; |
|
} |
|
public List<T> GetAllDisplayLayerInMap<T>() |
|
{ |
|
List<T> allLayers = new List<T>(); |
|
for (int i = 0; i < axMapControl.Map.LayerCount; i++) |
|
{ |
|
ILayer layer = axMapControl.Map.get_Layer(i); |
|
if (layer is ICompositeLayer) |
|
{ |
|
if (!layer.Visible) |
|
{ |
|
continue; |
|
} |
|
allLayers.AddRange(GetAllDisplayLayerInGroupLayer<T>(layer as ICompositeLayer)); |
|
} |
|
else |
|
{ |
|
if (layer is T) |
|
{ |
|
if (layer.Visible) |
|
{ |
|
allLayers.Add((T)layer); |
|
} |
|
|
|
} |
|
} |
|
} |
|
return allLayers; |
|
} |
|
public List<T> GetAllDisplayLayerInGroupLayer<T>(ICompositeLayer pCompLayer) |
|
{ |
|
List<T> allLayers = new List<T>(); |
|
try |
|
{ |
|
IFeatureLayer layer = null; |
|
for (int j = 0; j < pCompLayer.Count; j++) |
|
{ |
|
if (pCompLayer.get_Layer(j) is IFeatureLayer) |
|
{ |
|
layer = pCompLayer.get_Layer(j) as IFeatureLayer; |
|
if (layer.Visible) |
|
{ |
|
allLayers.Add((T)layer); |
|
} |
|
|
|
} |
|
else if (pCompLayer.get_Layer(j) is IGroupLayer) |
|
{ |
|
if (!pCompLayer.get_Layer(j).Visible) |
|
{ |
|
continue; |
|
} |
|
allLayers.AddRange(GetAllDisplayLayerInGroupLayer<T>(pCompLayer.get_Layer(j) as ICompositeLayer)); |
|
} |
|
} |
|
return allLayers; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
return allLayers; |
|
} |
|
/// <summary> |
|
/// 根据索引获得地图上显示的图层 |
|
/// </summary> |
|
/// <param name="pMap">地图</param> |
|
/// <param name="index">索引</param> |
|
/// <returns>检索到的图层</returns> |
|
public IFeatureLayer GetMapDisLayer(IMap pMap, int index) |
|
{ |
|
IFeatureLayer layer = null; |
|
int ind = -1; |
|
try |
|
{ |
|
//IEnumLayer enumLayer= KGIS.Framework.Platform.Platform.Instance.MapsService.getAxMapControl().Map.Layers; |
|
ICompositeLayer pCompLayer; |
|
//遍历地图 |
|
for (int i = 0; i < pMap.LayerCount; i++) |
|
{ |
|
if (pMap.get_Layer(i) is IFeatureLayer) |
|
{ |
|
//获得图层要素 |
|
layer = pMap.get_Layer(i) as IFeatureLayer; |
|
if (layer.Visible) |
|
{ |
|
ind++; |
|
} |
|
if (ind == index) |
|
{ |
|
return layer; |
|
} |
|
} |
|
else if (pMap.get_Layer(i) is IGroupLayer) |
|
{ |
|
if (!pMap.get_Layer(i).Visible) |
|
{ |
|
continue; |
|
} |
|
//遍历图层组 |
|
pCompLayer = pMap.get_Layer(i) as ICompositeLayer; |
|
GetMapDisLayer(pCompLayer, index, ref layer, ref ind); |
|
if (layer != null) |
|
{ |
|
return layer; |
|
} |
|
} |
|
} |
|
return layer; |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
return layer; |
|
} |
|
} |
|
|
|
private void GetMapDisLayer(ICompositeLayer pCompLayer, int index, ref IFeatureLayer getLayer, ref int retIndex) |
|
{ |
|
try |
|
{ |
|
IFeatureLayer layer = null; |
|
for (int j = 0; j < pCompLayer.Count; j++) |
|
{ |
|
if (pCompLayer.get_Layer(j) is IFeatureLayer) |
|
{ |
|
layer = pCompLayer.get_Layer(j) as IFeatureLayer; |
|
if (layer.Visible) |
|
{ |
|
retIndex++; |
|
} |
|
if (retIndex == index) |
|
{ |
|
getLayer = layer; |
|
return; |
|
} |
|
} |
|
else if (pCompLayer.get_Layer(j) is IGroupLayer) |
|
{ |
|
if (!pCompLayer.get_Layer(j).Visible) |
|
{ |
|
continue; |
|
} |
|
GetMapDisLayer(pCompLayer.get_Layer(j) as ICompositeLayer, index, ref getLayer, ref retIndex); |
|
if (getLayer != null) |
|
{ |
|
return; |
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
} |
|
/// <summary> |
|
/// 获取当前地图控件在屏幕上的位置 |
|
/// </summary> |
|
/// <returns></returns> |
|
public System.Drawing.Point GetMapInScreenLocation(int pIndex) |
|
{ |
|
System.Drawing.Point result = new System.Drawing.Point(); |
|
try |
|
{ |
|
result = axMapControl.Parent.PointToScreen(new System.Drawing.Point(0, 0)); |
|
|
|
switch (pIndex) |
|
{ |
|
case 2: |
|
result.X += axMapControl.Width;//x为地图x坐标 |
|
break; |
|
case 3: |
|
result.X += axMapControl.Width;//x为地图x坐标 |
|
result.Y += axMapControl.Height;//y为地图y坐标 |
|
break; |
|
case 4: |
|
result.Y += axMapControl.Height;//y为地图y坐标 |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("获取屏幕坐标时发生异常！异常信息如下："); |
|
LogAPI.Debug(ex); |
|
LogAPI.Debug("异常信息结束。"); |
|
} |
|
return result; |
|
} |
|
|
|
public void SetIsLoad(bool isLoad) |
|
{ |
|
m_IsLoad = isLoad; |
|
} |
|
|
|
public bool GetIsLoad() |
|
{ |
|
return m_IsLoad; |
|
} |
|
|
|
public void SaveProject() |
|
{ |
|
try |
|
{ |
|
EngineEditor editor = new EngineEditorClass(); |
|
#region 修改在编辑状态时，快捷键保存工程不提示信息；修改人：白明雅；修改时间：2018-09-04 |
|
if (editor.EditState == esriEngineEditState.esriEngineStateEditing) |
|
{ |
|
MessageHelper.ShowTips("当前工程正处于编辑状态，保存之前请先结束编辑!"); |
|
return; |
|
} |
|
#endregion |
|
ProjectInfo ProInfo = (MapsManager.Instance.CurrProjectInfo as ProjectInfo); |
|
if (ProInfo == null) return; |
|
//保存地图文档 |
|
try |
|
{ |
|
IDataCatalogService _DataCatalog = BundleRuntime.Instance.GetFirstOrDefaultService<IDataCatalogService>(); |
|
if (_DataCatalog == null || _DataCatalog.CurrentLayers == null) return; |
|
GetLayersState(); |
|
//Xml数据 |
|
string Str = SerializeAPI.SerializeToXML<LayerCfg>(_DataCatalog.CurrentLayers as LayerCfg); |
|
Byte[] bytearr = Encoding.Default.GetBytes(Str); |
|
string strBase64 = Convert.ToBase64String(bytearr); |
|
ProInfo.TempData = strBase64; |
|
//当前地图范围 |
|
ProInfo.MapExtent = new PluginServiceInterface.MapExtent(); |
|
if (!axMapControl.ActiveView.Extent.IsEmpty)//添加图形非空判断 王欢 2019-03-21 |
|
{ |
|
ProInfo.MapExtent.XMax = axMapControl.ActiveView.Extent.XMax; |
|
ProInfo.MapExtent.YMax = axMapControl.ActiveView.Extent.YMax; |
|
ProInfo.MapExtent.XMin = axMapControl.ActiveView.Extent.XMin; |
|
ProInfo.MapExtent.YMin = axMapControl.ActiveView.Extent.YMin; |
|
} |
|
if (ProInfo.Save()) |
|
{ |
|
//MessageHelper.ShowTips("保存成功！"); |
|
} |
|
} |
|
catch (Exception ex1) |
|
{ |
|
LogAPI.Debug("在保存工程时发生异常，异常信息如下："); |
|
LogAPI.Debug(ex1); |
|
LogAPI.Debug(" 异常信息结束"); |
|
MessageHelper.ShowError("保存失败！" + ex1.Message); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("保存工程时发生异常，异常信息如下：" + ex.Message); |
|
} |
|
} |
|
public void SaveProjectForNoEditor() |
|
{ |
|
try |
|
{ |
|
ProjectInfo ProInfo = (MapsManager.Instance.CurrProjectInfo as ProjectInfo); |
|
if (ProInfo == null) return; |
|
//保存地图文档 |
|
try |
|
{ |
|
IDataCatalogService _DataCatalog = BundleRuntime.Instance.GetFirstOrDefaultService<IDataCatalogService>(); |
|
if (_DataCatalog == null || _DataCatalog.CurrentLayers == null) return; |
|
GetLayersState(); |
|
//Xml数据 |
|
string Str = SerializeAPI.SerializeToXML<LayerCfg>(_DataCatalog.CurrentLayers as LayerCfg); |
|
Byte[] bytearr = Encoding.Default.GetBytes(Str); |
|
string strBase64 = Convert.ToBase64String(bytearr); |
|
ProInfo.TempData = strBase64; |
|
//当前地图范围 |
|
ProInfo.MapExtent = new PluginServiceInterface.MapExtent(); |
|
if (!axMapControl.ActiveView.Extent.IsEmpty)//添加图形非空判断 王欢 2019-03-21 |
|
{ |
|
ProInfo.MapExtent.XMax = axMapControl.ActiveView.Extent.XMax; |
|
ProInfo.MapExtent.YMax = axMapControl.ActiveView.Extent.YMax; |
|
ProInfo.MapExtent.XMin = axMapControl.ActiveView.Extent.XMin; |
|
ProInfo.MapExtent.YMin = axMapControl.ActiveView.Extent.YMin; |
|
} |
|
if (ProInfo.Save()) |
|
{ |
|
//MessageHelper.ShowTips("保存成功！"); |
|
} |
|
} |
|
catch (Exception ex1) |
|
{ |
|
LogAPI.Debug("在保存工程时发生异常，异常信息如下："); |
|
LogAPI.Debug(ex1); |
|
LogAPI.Debug(" 异常信息结束"); |
|
MessageHelper.ShowError("保存失败！" + ex1.Message); |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("保存工程时发生异常，异常信息如下：" + ex.Message); |
|
} |
|
} |
|
/// <summary> |
|
/// 保存图层状态（透明度-比例尺-样式） |
|
/// </summary> |
|
private void GetLayersState() |
|
{ |
|
try |
|
{ |
|
if (_DataCatalog == null) |
|
_DataCatalog = BundleRuntime.Instance.GetFirstOrDefaultService<IDataCatalogService>(); |
|
//随时保存-重新获取 |
|
ISystemCfg cfg2 = BundleRuntime.Instance.GetFirstOrDefaultService<ISystemCfg>(); |
|
SystemCfg = cfg2.Load(); |
|
if (SystemCfg.JcLayerLoadCfg == null) |
|
{ |
|
SystemCfg.JcLayerLoadCfg = new List<LayerCfg>(); |
|
} |
|
ProjectInfo projectInfo = MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo; |
|
if (projectInfo == null || _DataCatalog.CurrentLayers == null) return; |
|
|
|
//获取图层样式 |
|
LayerCfg layerInfo = _DataCatalog.CurrentLayers as LayerCfg; |
|
List<LayerCfg> list = layerInfo.GetAllItem(); |
|
if (list != null && list.Count != 0) |
|
{ |
|
foreach (var item in list) |
|
{ |
|
if (item.Data is ILayer layer) |
|
{ |
|
if (layer is IFeatureLayer) |
|
{ |
|
#region 图层是否可选 |
|
item.Selectable = (layer as IFeatureLayer).Selectable; |
|
#endregion |
|
|
|
#region 图层显示 |
|
item.Visible = layer.Visible; |
|
#endregion |
|
|
|
#region 透明度 |
|
if (layer is ILayerEffects mLayerEffects) |
|
item.Transparency = mLayerEffects.Transparency; |
|
#endregion |
|
|
|
#region 比例尺 |
|
LayerCfg layerCfg = SystemCfg.JcLayerLoadCfg.FirstOrDefault(x => x.LayerName == item.LayerName); |
|
if (layerCfg != null) |
|
{ |
|
item.MinScale = layer.MinimumScale.ToInt(); |
|
item.MaxScale = layer.MaximumScale.ToInt();//.MaxScale; |
|
layerCfg.MinScale = item.MinScale; |
|
layerCfg.MaxScale = item.MaxScale; |
|
} |
|
#endregion |
|
|
|
#region 样式 |
|
Renderer randerer = SymbolConvert.Instance().GetRenderer((layer as IGeoFeatureLayer).Renderer); |
|
LabelingInfo labelingInfo = null; |
|
LabelStyleConvert styleConvert = new LabelStyleConvert(); |
|
List<LabelingInfo> labelInfo = styleConvert.EsriLabelToCustomLabels((layer 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; |
|
item.Symbol = adi.ToJson(); |
|
} |
|
#endregion |
|
|
|
IGeoFeatureLayer pGeoFeatureLayer = layer as IGeoFeatureLayer; |
|
#region 标注-测试 |
|
if (pGeoFeatureLayer != null && pGeoFeatureLayer.DisplayAnnotation == true && item != null) |
|
{ |
|
IAnnotateLayerPropertiesCollection m_AnnotateLayerPropertiesCollection = (layer as IGeoFeatureLayer).AnnotationProperties; |
|
if (m_AnnotateLayerPropertiesCollection != null) |
|
{ |
|
IAnnotateLayerProperties annotateLayerProperties = null; |
|
IElementCollection elementCollection = null; |
|
IElementCollection elementCollection2 = null; |
|
#region 实体化 |
|
for (int i = 0; i < m_AnnotateLayerPropertiesCollection.Count; i++) |
|
{ |
|
m_AnnotateLayerPropertiesCollection.QueryItem(i, out annotateLayerProperties, out elementCollection2, out elementCollection); |
|
if (annotateLayerProperties == null) continue; |
|
ILabelEngineLayerProperties labelEngineLayer = (annotateLayerProperties as IClone).Clone() as ILabelEngineLayerProperties; |
|
AdvancedAnnotationInfo annotationInfo = new AdvancedAnnotationInfo(); |
|
if (labelEngineLayer == null) continue; |
|
SimpleTextSymbol txtSymbol = AnnotationConvret.Instance().GetTextSymbol(labelEngineLayer.Symbol); |
|
if (txtSymbol != null) |
|
{ |
|
annotationInfo.AnnotationInfos.Symbol = txtSymbol; |
|
annotationInfo.AnnotationInfos.Expression = labelEngineLayer.Expression; |
|
annotationInfo.AnnotationInfos.DisplayAnnotation = true; |
|
item.Annotation = annotationInfo.ToJson(); |
|
} |
|
} |
|
} |
|
#endregion |
|
} |
|
#endregion |
|
} |
|
} |
|
} |
|
SystemCfg.Save(); |
|
if (false)//测试数据提取 |
|
{ |
|
string Str = SerializeAPI.SerializeToXML<LayerCfg>(_DataCatalog.CurrentLayers as LayerCfg); |
|
Byte[] bytearr = Encoding.Default.GetBytes(Str);//Encoding.UTF8.GetBytes(Str); |
|
using (Stream stream = new System.IO.FileStream(@"C:\Users\Administrator\Desktop\临时文档" + "\\" + "LatersSymbolToXML简单绘制2.xml", FileMode.Create, FileAccess.Write, FileShare.None)) |
|
{ |
|
stream.Write(bytearr, 0, bytearr.Length); |
|
stream.Close(); |
|
MessageHelper.ShowTips("提取成功！"); |
|
} |
|
} |
|
} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("UcMapControl.GetLayersState() 异常：" + ex.Message); |
|
LogAPI.Debug("UcMapControl.GetLayersState() 异常：" + ex.StackTrace); |
|
LogAPI.Debug("UcMapControl.GetLayersState() 异常：" + ex); |
|
throw ex; |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 图层标注设置 |
|
/// </summary> |
|
/// <param name="layer"></param> |
|
/// <param name="layerCfg"></param> |
|
private void SetLayerAnnotation(ILayer layer, LayerCfg layerCfg) |
|
{ |
|
try |
|
{ |
|
if (string.IsNullOrWhiteSpace(layerCfg.Annotation)) return; |
|
AdvancedAnnotationInfo advanced = new AdvancedAnnotationInfo(); |
|
advanced = AdvancedAnnotationInfo.FromJson(layerCfg.Annotation); |
|
ITextSymbol pTextSymbol = AnnotationConvret.Instance().GetSimpleTextSymbol(advanced.AnnotationInfos.Symbol); |
|
IGeoFeatureLayer pGeoFeatureLayer = layer as IGeoFeatureLayer; |
|
|
|
pGeoFeatureLayer.DisplayAnnotation = advanced.AnnotationInfos.DisplayAnnotation;//开启标注图层内要素 |
|
IBasicOverposterLayerProperties pBasicOverposterLayerProprties = new BasicOverposterLayerProperties |
|
{ |
|
FeatureType = advanced.AnnotationInfos.FeatureType |
|
}; |
|
ILabelEngineLayerProperties pLabelEngineLayerProperties = new LabelEngineLayerProperties() as ILabelEngineLayerProperties; |
|
pLabelEngineLayerProperties.Expression = advanced.AnnotationInfos.Expression; |
|
pLabelEngineLayerProperties.Symbol = pTextSymbol; |
|
pLabelEngineLayerProperties.BasicOverposterLayerProperties = pBasicOverposterLayerProprties; |
|
|
|
// 刷新地图 |
|
IAnnotateLayerProperties pAnnotateLayerProperties = pLabelEngineLayerProperties as IAnnotateLayerProperties; |
|
IAnnotateLayerPropertiesCollection pAnnotateLayerPropertiesCollection = pGeoFeatureLayer.AnnotationProperties; |
|
pAnnotateLayerPropertiesCollection.Clear(); |
|
pAnnotateLayerPropertiesCollection.Add(pAnnotateLayerProperties); |
|
axMapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewBackground, null, null); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("图层标注设置异常：" + ex.Message); |
|
} |
|
} |
|
|
|
public List<T> GetAllVisibleLayerInMap<T>() |
|
{ |
|
List<T> allLayers = new List<T>(); |
|
for (int i = 0; i < axMapControl.Map.LayerCount; i++) |
|
{ |
|
ILayer layer = axMapControl.Map.get_Layer(i); |
|
if (layer is ICompositeLayer) |
|
{ |
|
if (!layer.Visible) continue; |
|
allLayers.AddRange(GetAllVisibleLayerInGroupLayer<T>(layer as ICompositeLayer)); |
|
} |
|
else |
|
{ |
|
if (layer is T && layer.Visible) |
|
{ |
|
if ((layer.MinimumScale == 0 || layer.MinimumScale > axMapControl.MapScale) && (layer.MaximumScale == 0 || layer.MaximumScale < axMapControl.MapScale)) |
|
allLayers.Add((T)layer); |
|
} |
|
} |
|
} |
|
return allLayers; |
|
} |
|
|
|
public void RefreshToolState() |
|
{ |
|
if (!axMapControl.IsDisposed) |
|
RefreshToolState(axMapControl.CurrentTool); |
|
} |
|
|
|
public void SetCurrentTool(object tool) |
|
{ |
|
if (tool is ITool) |
|
{ |
|
axMapControl.CurrentTool = tool as ITool; |
|
RefreshToolState(tool); |
|
} |
|
} |
|
|
|
public ILayer GetGroupLayer(string strSearch) |
|
{ |
|
return GetGroupLayer(axMapControl.Map, strSearch); |
|
} |
|
|
|
#endregion |
|
|
|
#region IKMap |
|
public object Hook => axMapControl.Object; |
|
|
|
public object MapCtrl => axMapControl; |
|
public ControlsSynchronizer CtlsSynchronizer |
|
{ |
|
get |
|
{ |
|
try |
|
{ |
|
if (_CtrlSynchronizer == null) |
|
_CtrlSynchronizer = new ControlsSynchronizer(Hook as IMapControl3, null); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug(ex); |
|
} |
|
return _CtrlSynchronizer; |
|
} |
|
} |
|
public Control MapCtrlContainer => axMapControl.ContainingControl.ActiveControl; |
|
#endregion |
|
|
|
#region IDocumentView |
|
public string Header { get; set; } |
|
public bool IsOpened { get; set; } |
|
public bool AllowClose { get; set; } |
|
public bool IsFloat { get; set; } |
|
public bool IsActive { get; set; } |
|
public bool AllowFloat { get; set; } |
|
#endregion |
|
private void hoverButton1_Load(object sender, EventArgs e) |
|
{ |
|
|
|
} |
|
|
|
private void hoverButton1_MouseDown(object sender, MouseEventArgs e) |
|
{ |
|
popupCtrl.Show(); |
|
} |
|
|
|
#region 图片方位角 |
|
Dictionary<string, ESRI.ArcGIS.Geometry.IPoint> dicPic = new Dictionary<string, ESRI.ArcGIS.Geometry.IPoint>(); |
|
public void AddCameraPoint(object pCameraParams) |
|
{ |
|
try |
|
{ |
|
if (!(pCameraParams is List<AttachEntity>)) return; |
|
dicPic = new Dictionary<string, IPoint>(); |
|
currentEl = null; |
|
axMapControl.ActiveView.GraphicsContainer.Reset(); |
|
|
|
IElement CameraPointElm = null; // axMapControl.ActiveView.GraphicsContainer.Next(); |
|
while ((CameraPointElm = axMapControl.ActiveView.GraphicsContainer.Next()) != null) |
|
{ |
|
if ((CameraPointElm as IElementProperties).Name == "CameraPoint") |
|
break; |
|
} |
|
if (CameraPointElm == null) |
|
{ |
|
CameraPointElm = new GroupElementClass(); |
|
(CameraPointElm as IElementProperties).Name = "CameraPoint"; |
|
axMapControl.ActiveView.GraphicsContainer.AddElement(CameraPointElm, 1); |
|
} |
|
(CameraPointElm as IGroupElement).ClearElements();//.DeleteAllElements(); |
|
//if (pCameraParams != null) |
|
//{ |
|
List<AttachEntity> list = pCameraParams as List<AttachEntity>; |
|
foreach (AttachEntity item in list) |
|
{ |
|
IPoint point = new PointClass() { X = item.X, Y = item.Y }; |
|
if (!dicPic.ContainsKey(item.FJMC)) |
|
{ |
|
DrawAnglePoint(CameraPointElm as IGroupElement, point, item.Angle, item.FJMC, axMapControl, item.isCheck); |
|
dicPic.Add(item.FJMC, point); |
|
} |
|
} |
|
axMapControl.ActiveView.GraphicsContainer.Reset(); |
|
//} |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("方位角异常：" + ex.Message); |
|
MessageHelper.ShowError("方位角出现异常，请查看日志！"); |
|
} |
|
} |
|
|
|
/// <summary> |
|
/// 绘制带方向点 |
|
/// </summary> |
|
/// <param name="pt"></param> |
|
/// <param name="angle"></param> |
|
private void DrawAnglePoint(IGroupElement pGroupEle, IPoint point, double angle, string picName, object objmapcontrol, bool IsCheck) |
|
{ |
|
try |
|
{ |
|
PictureMarkerSymbolClass picMarkerSymbol = new PictureMarkerSymbolClass(); |
|
picMarkerSymbol.Angle = -angle; |
|
picMarkerSymbol.Size = 28; |
|
if (IsCheck) |
|
{ |
|
picMarkerSymbol.CreateMarkerSymbolFromFile(esriIPictureType.esriIPicturePNG, Application.StartupPath + "\\Plugins\\KGIS.Plugin.MapView\\Resources\\近景.png"); |
|
} |
|
else |
|
{ |
|
picMarkerSymbol.CreateMarkerSymbolFromFile(esriIPictureType.esriIPicturePNG, Application.StartupPath + "\\Plugins\\KGIS.Plugin.MapView\\Resources\\arrow_unselect.png"); |
|
} |
|
MarkerElementClass pMarkerAngleElement = new MarkerElementClass(); |
|
pMarkerAngleElement.Symbol = picMarkerSymbol; |
|
pMarkerAngleElement.Name = "ShowPicElement&" + picName; |
|
IElement pElement; |
|
pElement = pMarkerAngleElement as IElement; |
|
|
|
pElement.Geometry = point; |
|
pGroupEle.AddElement((IElement)pMarkerAngleElement); |
|
} |
|
catch (Exception ex) |
|
{ |
|
LogAPI.Debug("绘制带方向点异常：" + ex); |
|
} |
|
} |
|
IElement currentEl = null; |
|
|
|
public void ChangedPointSymbol(string elementName, bool ischeck) |
|
{ |
|
string elementNamePic = "ShowPicElement&" + elementName; |
|
|
|
axMapControl.ActiveView.GraphicsContainer.Reset(); |
|
IElement CameraPointElm = null; // axMapControl.ActiveView.GraphicsContainer.Next(); |
|
while ((CameraPointElm = axMapControl.ActiveView.GraphicsContainer.Next()) != null) |
|
{ |
|
if ((CameraPointElm as IElementProperties).Name == "CameraPoint") |
|
break; |
|
} |
|
if (CameraPointElm == null) |
|
{ |
|
CameraPointElm = new GroupElementClass(); |
|
(CameraPointElm as IElementProperties).Name = "CameraPoint"; |
|
} |
|
//(CameraPointElm as IGroupElement).Elements.Reset(); |
|
IEnumElement Elements = (CameraPointElm as IGroupElement).Elements; |
|
//Elements.Reset(); |
|
IElement el = Elements.Next(); |
|
//int num = (CameraPointElm as IGroupElement).ElementCount; |
|
if (el == null) |
|
{ |
|
Elements.Reset(); |
|
el = Elements.Next(); |
|
} |
|
if (currentEl is IMarkerElement) |
|
{ |
|
IMarkerElement elMarker = currentEl as IMarkerElement; |
|
if (elMarker.Symbol is IPictureMarkerSymbol) |
|
{ |
|
IPictureMarkerSymbol picSymbol = elMarker.Symbol as IPictureMarkerSymbol; |
|
if (ischeck) |
|
{ |
|
picSymbol.CreateMarkerSymbolFromFile(esriIPictureType.esriIPicturePNG, System.Windows.Forms.Application.StartupPath + "\\Plugins\\KGIS.Plugin.MapView\\Resources\\近景.png"); |
|
} |
|
else |
|
{ |
|
picSymbol.CreateMarkerSymbolFromFile(esriIPictureType.esriIPicturePNG, System.Windows.Forms.Application.StartupPath + "\\Plugins\\KGIS.Plugin.MapView\\Resources\\arrow_unselect.png"); |
|
} |
|
elMarker.Symbol = picSymbol; |
|
} |
|
} |
|
while (el != null) |
|
{ |
|
if (el == null) return; |
|
if (el is IMarkerElement) |
|
{ |
|
IElementProperties elementPro = el as IElementProperties; |
|
if (!elementPro.Name.StartsWith("ShowPicElement")) continue; |
|
if (elementPro.Name == elementNamePic) |
|
{ |
|
IMarkerElement elMarker = el as IMarkerElement; |
|
if (elMarker == null) continue; |
|
IPictureMarkerSymbol picSymbol = elMarker.Symbol as IPictureMarkerSymbol; |
|
if (picSymbol == null) continue; |
|
picSymbol.CreateMarkerSymbolFromFile(esriIPictureType.esriIPicturePNG, System.Windows.Forms.Application.StartupPath + "\\Plugins\\KGIS.Plugin.MapView\\Resources\\arrow_select.png"); |
|
elMarker.Symbol = picSymbol; |
|
currentEl = el; |
|
break; |
|
} |
|
} |
|
el = Elements.Next(); |
|
} |
|
axMapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, null); |
|
} |
|
#endregion |
|
public object GetAllEditOID() |
|
{ |
|
try |
|
{ |
|
IWorkspaceEdit2 workspaceEdit2 = (IWorkspaceEdit2)editor.EditWorkspace; |
|
IDataChangesEx dataChangesEx = workspaceEdit2.get_EditDataChanges(esriEditDataChangesType.esriEditDataChangesWithinSession); |
|
//获取所有变化的要素集 |
|
//String modifiedClass = null; |
|
//ESRI.ArcGIS.esriSystem.IEnumBSTR modifiedClasses = dataChangesEx.ModifiedClasses; |
|
//if (modifiedClasses == null) |
|
// return null; |
|
Dictionary<string, List<int>> objids = new Dictionary<string, List<int>>(); |
|
objids.Add("修改", new List<int>()); |
|
objids.Add("新增", new List<int>()); |
|
objids.Add("删除", new List<int>()); |
|
//图层名称 |
|
//while ((modifiedClass = modifiedClasses.Next()) != null) |
|
//{ |
|
//获取当前要素类所有变化图形信息 |
|
IFIDSet fids = dataChangesEx.ChangedIDs["DLTBBG", esriDifferenceType.esriDifferenceTypeUpdateNoChange]; |
|
#region 参数 |
|
//准备输入参数 |
|
int featureOID = -1; |
|
#endregion |
|
|
|
fids.Next(out featureOID); |
|
while (featureOID != -1) |
|
{ |
|
if (!objids["修改"].Contains(featureOID)) |
|
objids["修改"].Add(featureOID); |
|
fids.Next(out featureOID); |
|
} |
|
//获取删除图形信息 |
|
fids = dataChangesEx.ChangedIDs["DLTBBG", esriDifferenceType.esriDifferenceTypeDeleteNoChange]; |
|
fids.Next(out featureOID); |
|
while (featureOID != -1) |
|
{ |
|
if (!objids["删除"].Contains(featureOID)) |
|
objids["删除"].Add(featureOID); |
|
fids.Next(out featureOID); |
|
} |
|
//获取插入图形信息 |
|
fids = dataChangesEx.ChangedIDs["DLTBBG", esriDifferenceType.esriDifferenceTypeInsert]; |
|
fids.Next(out featureOID); |
|
while (featureOID != -1) |
|
{ |
|
if (!objids["新增"].Contains(featureOID)) |
|
objids["新增"].Add(featureOID); |
|
fids.Next(out featureOID); |
|
} |
|
System.Runtime.InteropServices.Marshal.FinalReleaseComObject(fids); |
|
//} |
|
return objids; |
|
} |
|
catch (Exception) |
|
{ |
|
|
|
throw; |
|
} |
|
} |
|
#endregion |
|
} |
|
public class WorkCatalogPaths |
|
{ |
|
public override string ToString() { return WorkCatalogPath; } |
|
/// <summary> |
|
/// 工作目录路径 |
|
/// </summary> |
|
public string WorkCatalogPath { get; set; } |
|
public string CODE { get; set; } |
|
public string DisplayName { get; set; } |
|
public DateTime UpdateTime { get; set; } |
|
} |
|
}
|
|
|