private void GeometryNewConnectivityPropertyPage_Load(object sender, EventArgs e)
{
IFeatureClass class3;
IEnumFeatureClass class2 = this.igeometricNetwork_0.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
this.cboConnectivityRule.Properties.Items.Add(new FeatureClassWrap(class3));
}
class2 = this.igeometricNetwork_0.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
this.cboConnectivityRule.Properties.Items.Add(new FeatureClassWrap(class3));
}
class2 = this.igeometricNetwork_0.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
this.cboConnectivityRule.Properties.Items.Add(new FeatureClassWrap(class3));
}
class2 = this.igeometricNetwork_0.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
this.cboConnectivityRule.Properties.Items.Add(new FeatureClassWrap(class3));
}
this.method_0(this.igeometricNetwork_0);
}
/// <summary>
/// Determines whether the specified network element corresponds to the required generic junction feature class.
/// </summary>
/// <param name="junctionEID">The junction EID.</param>
/// <returns>
/// <c>true</c> if the specified network element corresponds to the required generic junction feature class; otherwise,
/// <c>false</c>.
/// </returns>
protected bool IsGenericJunction(int junctionEID)
{
if (_JunctionsClassID < 0)
{
// Determine the generic junction class ID.
IFeatureClassContainer container = (IFeatureClassContainer)this.GeometricNetwork;
IEnumFeatureClass enumClasses = container.Classes;
enumClasses.Reset();
// Iterate through all of the classes that participate in the network.
IFeatureClass networkClass;
while ((networkClass = enumClasses.Next()) != null)
{
if (this.IsGenericJunction(networkClass))
{
_JunctionsClassID = networkClass.ObjectClassID;
break;
}
}
}
// Determine the class identifier for the element.
IEIDInfo eidInfo = this.GetEIDInfo(junctionEID, esriElementType.esriETJunction);
// When the class ID equals the generic junction.
return(eidInfo.Feature.Class.ObjectClassID == _JunctionsClassID);
}
/// <summary>
/// 为要素类添加拓扑规则，针对针对特殊的要素类检查
/// </summary>
/// <param name="pTopo">拓扑</param>
/// <param name="pTopoRuleType">拓扑规则</param>
/// <param name="outError">异常</param>
public void AddRuletoTopology(ITopology pTopo, esriTopologyRuleType pTopoRuleType, out Exception outError)
{
outError = null;
try
{
ITopologyRuleContainer pRuleContainer = pTopo as ITopologyRuleContainer;
IFeatureClassContainer pFeaClsContainer = pTopo as IFeatureClassContainer;
IEnumFeatureClass pEnumFeaCls = pFeaClsContainer.Classes;
pEnumFeaCls.Reset();
IFeatureClass pFeaCls = pEnumFeaCls.Next();
//设置拓扑规则
while (pFeaCls != null)
{
ITopologyRule pTopoRule = new TopologyRuleClass();
pTopoRule.TopologyRuleType = pTopoRuleType;
pTopoRule.Name = (pFeaCls as IDataset).Name;
pTopoRule.OriginClassID = pFeaCls.FeatureClassID;
pTopoRule.AllOriginSubtypes = true;
pRuleContainer.AddRule(pTopoRule);
pFeaCls = pEnumFeaCls.Next();
}
}
catch (Exception ex)
{
////*********************************************
////guozheng 2010-12-24 平安夜 added 系统异常日志
//if (ModData.SysLog == null) ModData.SysLog = new clsWriteSystemFunctionLog();
//ModData.SysLog.Write(ex);
////**********************************************
outError = ex;
}
}
private void GeometryNetGeneralPropertyPage_Load(object sender, EventArgs e)
{
ListViewItem item;
this.textEdit1.Text = (this.igeometricNetwork_0 as IDataset).Name;
IEnumFeatureClass class2 = this.igeometricNetwork_0.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
class2.Reset();
IFeatureClass class3 = class2.Next();
string[] items = new string[2];
while (class3 != null)
{
items[0] = class3.AliasName;
items[1] = "简单连接点";
item = new ListViewItem(items);
this.listView1.Items.Add(item);
class3 = class2.Next();
}
class2 = this.igeometricNetwork_0.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
items[0] = class3.AliasName;
items[1] = "复杂连接点";
item = new ListViewItem(items);
this.listView1.Items.Add(item);
}
class2 = this.igeometricNetwork_0.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
items[0] = class3.AliasName;
items[1] = "简单边";
item = new ListViewItem(items);
this.listView1.Items.Add(item);
}
class2 = this.igeometricNetwork_0.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
items[0] = class3.AliasName;
items[1] = "复杂边";
item = new ListViewItem(items);
this.listView1.Items.Add(item);
}
}
/// <summary>
/// Find Nearest Distance
/// </summary>
/// <param name="enumFeatureClass">object enumFeatureClass</param>
/// <param name="point">point source</param>
/// <param name="searchTolerance">search tolerance</param>
/// <param name="distance">distance found</param>
/// <param name="featureClassID">featureClassID found</param>
/// <param name="featureGeometry">featureGeometry found</param>
internal static void FindNearestDistance(IEnumFeatureClass enumFeatureClass, IPoint point, double searchTolerance, ref double distance, ref int featureClassID, ref IGeometry featureGeometry)
{
enumFeatureClass.Reset();
IFeatureClass featureClass = enumFeatureClass.Next();
while (featureClass != null)
{
string shapeFieldName = featureClass.ShapeFieldName;
ITopologicalOperator topologicalOperator = point as ITopologicalOperator;
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = topologicalOperator.Buffer(searchTolerance);
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
spatialFilter.GeometryField = shapeFieldName;
IFeatureCursor featureCursor = null;
try
{
////using (ComReleaser comReleaser = new ComReleaser())
////{
featureCursor = featureClass.Search(spatialFilter, true);
////comReleaser.ManageLifetime(featureCursor);
IFeature feature = featureCursor.NextFeature();
while (feature != null)
{
IProximityOperator proximityOperator = feature.ShapeCopy as IProximityOperator;
double distanceCurrent = proximityOperator.ReturnDistance(point);
if (distance > distanceCurrent)
{
distance = distanceCurrent;
featureClassID = featureClass.FeatureClassID;
featureGeometry = feature.ShapeCopy;
}
feature = featureCursor.NextFeature();
}
////}
}
catch
{
throw;
}
finally
{
if (featureCursor != null)
{
Marshal.ReleaseComObject(featureCursor);
}
}
featureClass = enumFeatureClass.Next();
}
}
/// <summary>
/// Creates an <see cref="IEnumerable{T}" /> from an <see cref="IEnumFeatureClass" />
/// </summary>
/// <param name="source">An <see cref="IEnumFeatureClass" /> to create an <see cref="IEnumerable{T}" /> from.</param>
/// <returns>An <see cref="IEnumerable{T}" /> that contains the feature classes from the input source.</returns>
public static IEnumerable <IFeatureClass> AsEnumerable(this IEnumFeatureClass source)
{
if (source != null)
{
source.Reset();
IFeatureClass featureclass = source.Next();
while (featureclass != null)
{
yield return(featureclass);
featureclass = source.Next();
}
}
}
public static bool isAllowedDatasetFC(string sLayer)
{
bool bRetVal = false;
ESRI.ArcGIS.Geodatabase.IWorkspace pWorkSpace;
using (CSpatialSubs oSpatialSubs = new CSpatialSubs())
{
pWorkSpace = oSpatialSubs.returnEditableSDEWorkspace();
}
if (pWorkSpace != null)
{
// get the feature classes from each dataset
IEnumDataset enumFeatureDatasets = pWorkSpace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
enumFeatureDatasets.Reset();
IFeatureDataset featureDataset = (IFeatureDataset)enumFeatureDatasets.Next();
while (featureDataset != null)
{
ISQLPrivilege oDSPriv = (ISQLPrivilege)featureDataset.FullName;
int iDSPriv = oDSPriv.SQLPrivileges;
if (iDSPriv > 1)
{
IFeatureClassContainer fcContainer = (IFeatureClassContainer)featureDataset;
IEnumFeatureClass enumFeatureClasses = fcContainer.Classes;
enumFeatureClasses.Reset();
IFeatureClass fc = (IFeatureClass)enumFeatureClasses.Next();
while (fc != null)
{
if (sLayer == fc.AliasName.ToString())
{
bRetVal = true;
break;
}
fc = (IFeatureClass)enumFeatureClasses.Next();
}
}
featureDataset = (IFeatureDataset)enumFeatureDatasets.Next();
}
}
return(bRetVal);
}
private void TopologyClassesPropertyPage_Load(object sender, EventArgs e)
{
try
{
int num2;
TopologyEditHelper.m_pList.RemoveAll();
this.vertXtraGrid_0.EditorName = "要素类";
this.vertXtraGrid_0.EditorValue = "优先级";
int num = 1;
IEnumFeatureClass classes = (this.itopology_0 as IFeatureClassContainer).Classes;
classes.Reset();
ITopologyClass class3 = classes.Next() as ITopologyClass;
IList list = new ArrayList();
for (num2 = 1; num2 <= num; num2++)
{
list.Add(num2);
}
while (class3 != null)
{
if (class3.IsInTopology)
{
num = (num < class3.XYRank) ? class3.XYRank : num;
this.vertXtraGrid_0.AddComBoBox((class3 as IDataset).Name, class3.XYRank, list, false,
new Class6(class3, false));
TopologyEditHelper.m_pList.Add(class3);
}
class3 = classes.Next() as ITopologyClass;
}
this.txtValue.Value = num;
list.Clear();
for (num2 = 1; num2 <= num; num2++)
{
list.Add(num2);
}
for (num2 = 0; num2 < this.gridView1.RowCount; num2++)
{
this.vertXtraGrid_0.ChangeItem(num2, ColumnAttribute.CA_COMBOBOX, list, 0.0, 0.0);
}
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
this.bool_0 = true;
}
public static void AddDataset(IBasicMap pMap, IDataset pDataset, string dsName)
{
IFeatureLayer fDOGraphicsLayerClass;
IFeatureClass j;
IFeatureLayer featureLayerClass;
if (dsName == null)
{
dsName = "";
}
switch (pDataset.Type)
{
case esriDatasetType.esriDTFeatureDataset:
{
IEnumDataset subsets = pDataset.Subsets;
subsets.Reset();
for (IDataset i = subsets.Next(); i != null; i = subsets.Next())
{
MapHelper.AddDataset(pMap, i, dsName);
}
return;
}
case esriDatasetType.esriDTFeatureClass:
{
IFeatureClass idataset0 = (IFeatureClass)pDataset;
if (idataset0.FeatureType == esriFeatureType.esriFTAnnotation)
{
fDOGraphicsLayerClass = new FDOGraphicsLayerClass();
try
{
fDOGraphicsLayerClass.FeatureClass = idataset0;
fDOGraphicsLayerClass.Name = string.Concat(dsName, idataset0.AliasName);
pMap.AddLayer(fDOGraphicsLayerClass);
return;
}
catch (Exception exception)
{
exception.ToString();
return;
}
}
else if (idataset0.FeatureType != esriFeatureType.esriFTDimension)
{
fDOGraphicsLayerClass = new FeatureLayerClass()
{
FeatureClass = idataset0,
Name = string.Concat(dsName, idataset0.AliasName)
};
pMap.AddLayer(fDOGraphicsLayerClass);
return;
}
else
{
fDOGraphicsLayerClass = new DimensionLayerClass()
{
FeatureClass = idataset0,
Name = string.Concat(dsName, idataset0.AliasName)
};
pMap.AddLayer(fDOGraphicsLayerClass);
return;
}
break;
}
case esriDatasetType.esriDTPlanarGraph:
case esriDatasetType.esriDTText:
case esriDatasetType.esriDTRelationshipClass:
{
return;
}
case esriDatasetType.esriDTGeometricNetwork:
{
IGeometricNetwork geometricNetwork = pDataset as IGeometricNetwork;
if (geometricNetwork == null)
{
return;
}
IEnumFeatureClass classesByType =
geometricNetwork.ClassesByType[esriFeatureType.esriFTSimpleJunction];
classesByType.Reset();
for (j = classesByType.Next(); j != null; j = classesByType.Next())
{
featureLayerClass = new FeatureLayerClass()
{
FeatureClass = j,
Name = string.Concat(dsName, (j as IDataset).Name)
};
pMap.AddLayer(featureLayerClass);
}
classesByType = geometricNetwork.ClassesByType[esriFeatureType.esriFTComplexJunction];
classesByType.Reset();
for (j = classesByType.Next(); j != null; j = classesByType.Next())
{
featureLayerClass = new FeatureLayerClass()
{
FeatureClass = j,
Name = string.Concat(dsName, (j as IDataset).Name)
};
pMap.AddLayer(featureLayerClass);
}
classesByType = geometricNetwork.ClassesByType[esriFeatureType.esriFTSimpleEdge];
classesByType.Reset();
for (j = classesByType.Next(); j != null; j = classesByType.Next())
{
featureLayerClass = new FeatureLayerClass()
{
FeatureClass = j,
Name = string.Concat(dsName, (j as IDataset).Name)
};
pMap.AddLayer(featureLayerClass);
}
classesByType = geometricNetwork.ClassesByType[esriFeatureType.esriFTComplexEdge];
classesByType.Reset();
for (j = classesByType.Next(); j != null; j = classesByType.Next())
{
featureLayerClass = new FeatureLayerClass()
{
FeatureClass = j,
Name = string.Concat(dsName, (j as IDataset).Name)
};
pMap.AddLayer(featureLayerClass);
}
return;
}
case esriDatasetType.esriDTTopology:
{
ITopologyLayer topologyLayerClass = new TopologyLayerClass()
{
Topology = pDataset as ITopology
};
(topologyLayerClass as ILayer).Name = string.Concat(dsName, pDataset.Name);
pMap.AddLayer(topologyLayerClass as ILayer);
return;
}
case esriDatasetType.esriDTTable:
{
try
{
IRasterCatalogTable rasterCatalogTableClass = new RasterCatalogTable()
{
Table = (ITable)pDataset
};
rasterCatalogTableClass.Update();
IRasterCatalogLayer rasterCatalogLayerClass = new RasterCatalogLayerClass();
rasterCatalogLayerClass.Create(rasterCatalogTableClass);
rasterCatalogLayerClass.Name = string.Concat(dsName, pDataset.BrowseName);
pMap.AddLayer(rasterCatalogLayerClass);
return;
}
catch
{
try
{
IStandaloneTableCollection ibasicMap0 = pMap as IStandaloneTableCollection;
IPropertySet connectionProperties = pDataset.Workspace.ConnectionProperties;
bool flag = false;
int num = 0;
while (true)
{
if (num < ibasicMap0.StandaloneTableCount)
{
ITable table = ibasicMap0.StandaloneTable[num].Table;
if (
!connectionProperties.IsEqual((table as IDataset).Workspace.ConnectionProperties) ||
!((table as IDataset).Name == pDataset.Name))
{
num++;
}
else
{
flag = true;
break;
}
}
else
{
break;
}
}
if (!flag)
{
ibasicMap0.AddStandaloneTable(new StandaloneTableClass()
{
Table = pDataset as ITable
});
}
}
catch (Exception exception1)
{
Logger.Current.Write(exception1.Message, LogLevel.Error, null);
}
return;
}
break;
}
case esriDatasetType.esriDTRasterDataset:
case esriDatasetType.esriDTRasterBand:
{
IRasterLayer rasterLayerClass = new RasterLayerClass();
rasterLayerClass.CreateFromDataset((IRasterDataset)pDataset);
rasterLayerClass.Name = string.Concat(dsName, pDataset.Name);
pMap.AddLayer(rasterLayerClass);
return;
}
case esriDatasetType.esriDTTin:
{
ITinLayer tinLayerClass = new TinLayerClass()
{
Dataset = (ITin)pDataset,
Name = string.Concat(dsName, pDataset.Name)
};
pMap.AddLayer(tinLayerClass);
return;
}
case esriDatasetType.esriDTCadDrawing:
{
ICadLayer cadLayerClass = new CadLayerClass()
{
CadDrawingDataset = pDataset as ICadDrawingDataset,
Name = pDataset.Name
};
pMap.AddLayer(cadLayerClass);
return;
}
default:
{
return;
}
}
}
public void LoadData(IList ilist_0)
{
IEnumDataset subsets;
IDataset j;
string str;
IFeatureClass dataset;
IFeatureLayer cadFeatureLayerClass;
ITopologyLayer topologyLayerClass;
IEnumFeatureClass classes;
IFeatureClass m;
IFeatureClass n;
IFeatureLayer featureLayerClass;
List <object> objs = new List <object>();
foreach (object ilist0 in ilist_0)
{
if (ilist0 is IGxDataset)
{
if ((ilist0 as IGxDataset).Type != esriDatasetType.esriDTFeatureDataset)
{
objs.Add(ilist0);
}
else
{
IEnumGxObject children = (ilist0 as IGxObjectContainer).Children;
children.Reset();
for (IGxObject i = children.Next(); i != null; i = children.Next())
{
objs.Add(i);
}
}
}
else if (!(ilist0 is IDataset))
{
objs.Add(ilist0);
}
else
{
if ((ilist0 as IDataset).Type != esriDatasetType.esriDTFeatureDataset)
{
continue;
}
subsets = (ilist0 as IDataset).Subsets;
subsets.Reset();
for (j = subsets.Next(); j != null; j = subsets.Next())
{
objs.Add(j);
}
}
}
ProcessAssist processAssist = new ProcessAssist();
processAssist.InitProgress();
processAssist.SetMaxValue(objs.Count);
processAssist.SetMessage("正在加载数据,请稍候...");
processAssist.Start();
try
{
ILayer layer = null;
IMap map = this.GetMap();
this.list_0 = new List <ILayer>();
List <string> strs = new List <string>();
IEnvelope envelope = null;
IDataset item = null;
IGxDataset gxDataset = null;
for (int k = 0; k < objs.Count; k++)
{
string name = "";
if (objs[k] is IGxObject)
{
name = (objs[k] as IGxObject).Name;
}
else if (objs[k] is IDataset)
{
name = (objs[k] as IDataset).Name;
}
bool flag = true;
str = string.Format("加载图层[{0}]，第{1}/{2}个", name, k + 1, objs.Count);
processAssist.Increment(1);
processAssist.SetMessage(str);
if (objs[k] is IGxLayer)
{
layer = (objs[k] as IGxLayer).Layer;
if (layer is IGeoDataset && !SpatialReferenctOperator.ValideFeatureClass(layer as IGeoDataset))
{
strs.Add(layer.Name);
flag = false;
}
this.AddLayer(map, layer, ref envelope, flag);
}
else if (!(objs[k] is IGxAGSObject))
{
if (objs[k] is IGxDataset)
{
gxDataset = objs[k] as IGxDataset;
item = gxDataset.Dataset;
}
else if (ilist_0[k] is IDataset)
{
item = objs[k] as IDataset;
}
if (item != null)
{
if (item is IGeoDataset)
{
flag = SpatialReferenctOperator.ValideFeatureClass(item as IGeoDataset);
}
if (item.Type == esriDatasetType.esriDTFeatureClass)
{
dataset = (IFeatureClass)item;
if ((gxDataset as IGxObject).Category.IndexOf("CAD") != -1)
{
if (dataset.FeatureType != esriFeatureType.esriFTCoverageAnnotation)
{
cadFeatureLayerClass = new CadFeatureLayerClass();
}
else
{
cadFeatureLayerClass = new CadAnnotationLayerClass();
}
cadFeatureLayerClass.FeatureClass = dataset;
cadFeatureLayerClass.Name = dataset.AliasName;
}
else if (dataset.FeatureType == esriFeatureType.esriFTAnnotation)
{
cadFeatureLayerClass = new FDOGraphicsLayerClass()
{
FeatureClass = dataset,
Name = dataset.AliasName
};
}
else if (dataset.FeatureType != esriFeatureType.esriFTDimension)
{
cadFeatureLayerClass = new FeatureLayerClass()
{
FeatureClass = dataset,
Name = dataset.AliasName
};
}
else
{
cadFeatureLayerClass = new DimensionLayerClass()
{
FeatureClass = dataset,
Name = dataset.AliasName
};
}
if (!flag)
{
strs.Add(cadFeatureLayerClass.Name);
}
this.AddLayer(map, cadFeatureLayerClass, ref envelope, flag);
}
else if (item.Type == esriDatasetType.esriDTCadDrawing)
{
if ((gxDataset as IGxObject).Category != "CAD绘图")
{
IEnumGxObject enumGxObject = (gxDataset as IGxObjectContainer).Children;
enumGxObject.Reset();
for (IGxDataset l = enumGxObject.Next() as IGxDataset; l != null; l = enumGxObject.Next() as IGxDataset)
{
dataset = l.Dataset as IFeatureClass;
if (dataset != null)
{
if (dataset.FeatureType != esriFeatureType.esriFTAnnotation)
{
cadFeatureLayerClass = new CadFeatureLayerClass()
{
FeatureClass = dataset,
Name = dataset.AliasName
};
}
else
{
cadFeatureLayerClass = new FDOGraphicsLayerClass()
{
FeatureClass = dataset,
Name = dataset.AliasName
};
}
flag = true;
if (cadFeatureLayerClass is IGeoDataset)
{
bool flag1 = SpatialReferenctOperator.ValideFeatureClass(cadFeatureLayerClass as IGeoDataset);
flag = flag1;
if (!flag1)
{
strs.Add(cadFeatureLayerClass.Name);
}
}
this.AddLayer(map, cadFeatureLayerClass, ref envelope, flag);
}
}
}
else
{
ICadLayer cadLayerClass = new CadLayerClass()
{
CadDrawingDataset = gxDataset.Dataset as ICadDrawingDataset,
Name = gxDataset.Dataset.Name
};
if (!flag)
{
strs.Add(cadLayerClass.Name);
}
this.AddLayer(map, cadLayerClass, ref envelope, flag);
}
}
else if (item.Type == esriDatasetType.esriDTFeatureDataset)
{
subsets = item.Subsets;
subsets.Reset();
for (j = subsets.Next(); j != null; j = subsets.Next())
{
if (j.Type == esriDatasetType.esriDTFeatureClass)
{
dataset = j as IFeatureClass;
if (dataset.FeatureType != esriFeatureType.esriFTAnnotation)
{
cadFeatureLayerClass = new FeatureLayerClass()
{
FeatureClass = dataset,
Name = dataset.AliasName
};
flag = true;
if (cadFeatureLayerClass is IGeoDataset)
{
bool flag2 = SpatialReferenctOperator.ValideFeatureClass(cadFeatureLayerClass as IGeoDataset);
flag = flag2;
if (!flag2)
{
strs.Add(cadFeatureLayerClass.Name);
}
}
this.AddLayer(map, cadFeatureLayerClass, ref envelope, flag);
}
else
{
cadFeatureLayerClass = new FDOGraphicsLayerClass()
{
FeatureClass = dataset,
Name = dataset.AliasName
};
flag = true;
if (cadFeatureLayerClass is IGeoDataset)
{
bool flag3 = SpatialReferenctOperator.ValideFeatureClass(cadFeatureLayerClass as IGeoDataset);
flag = flag3;
if (!flag3)
{
strs.Add(cadFeatureLayerClass.Name);
}
}
this.AddLayer(map, cadFeatureLayerClass, ref envelope, flag);
}
}
else if (j.Type == esriDatasetType.esriDTTopology)
{
topologyLayerClass = new TopologyLayerClass()
{
Topology = j as ITopology
};
(topologyLayerClass as ILayer).Name = j.Name;
this.AddLayer(map, topologyLayerClass as ILayer, ref envelope, true);
}
}
}
else if (item.Type == esriDatasetType.esriDTTopology)
{
if (MessageBox.Show(string.Concat("是否将参加拓扑-", item.Name, "-的所有要素添加到地图中"), "添加拓扑层", MessageBoxButtons.YesNo, MessageBoxIcon.Asterisk) == DialogResult.Yes)
{
classes = (item as IFeatureClassContainer).Classes;
classes.Reset();
for (m = classes.Next(); m != null; m = classes.Next())
{
cadFeatureLayerClass = new FeatureLayerClass()
{
FeatureClass = m,
Name = m.AliasName
};
flag = true;
if (cadFeatureLayerClass is IGeoDataset)
{
bool flag4 = SpatialReferenctOperator.ValideFeatureClass(cadFeatureLayerClass as IGeoDataset);
flag = flag4;
if (!flag4)
{
strs.Add(cadFeatureLayerClass.Name);
}
}
this.AddLayer(map, cadFeatureLayerClass, ref envelope, flag);
}
}
topologyLayerClass = new TopologyLayerClass()
{
Topology = item as ITopology
};
(topologyLayerClass as ILayer).Name = item.Name;
this.AddLayer(map, topologyLayerClass as ILayer, ref envelope, true);
}
else if (item.Type == esriDatasetType.esriDTTin)
{
ITinLayer tinLayerClass = new TinLayerClass()
{
Dataset = (ITin)item,
Name = item.Name
};
flag = true;
if (tinLayerClass is IGeoDataset)
{
bool flag5 = SpatialReferenctOperator.ValideFeatureClass(tinLayerClass as IGeoDataset);
flag = flag5;
if (!flag5)
{
strs.Add(tinLayerClass.Name);
}
}
this.AddLayer(map, tinLayerClass, ref envelope, flag);
}
else if (item.Type == esriDatasetType.esriDTRasterCatalog)
{
IGdbRasterCatalogLayer gdbRasterCatalogLayerClass = null;
gdbRasterCatalogLayerClass = new GdbRasterCatalogLayerClass();
if (gdbRasterCatalogLayerClass.Setup((ITable)(item as IRasterCatalog)))
{
bool flag6 = SpatialReferenctOperator.ValideFeatureClass(gdbRasterCatalogLayerClass as IGeoDataset);
flag = flag6;
if (!flag6)
{
strs.Add((gdbRasterCatalogLayerClass as ILayer).Name);
}
this.AddLayer(map, gdbRasterCatalogLayerClass as ILayer, ref envelope, flag);
}
}
else if (!(item.Type == esriDatasetType.esriDTRasterDataset ? false : item.Type != esriDatasetType.esriDTRasterBand))
{
bool flag7 = true;
if (!((IRasterPyramid)item).Present)
{
if (this.m_pApp.PyramidPromptType == PyramidPromptType.AlwaysBuildNoPrompt)
{
((IRasterPyramid)item).Create();
}
else if (this.m_pApp.PyramidPromptType == PyramidPromptType.AlwaysPrompt)
{
DialogResult dialogResult = BuildPyramidSet.Show();
if (dialogResult == DialogResult.Yes)
{
((IRasterPyramid)item).Create();
}
else if (dialogResult == DialogResult.Cancel)
{
flag7 = false;
}
}
}
if (flag7)
{
IRasterLayer rasterLayerClass = new RasterLayerClass()
{
Cached = true
};
rasterLayerClass.CreateFromDataset((IRasterDataset)item);
rasterLayerClass.Name = item.Name;
bool flag8 = SpatialReferenctOperator.ValideFeatureClass(rasterLayerClass as IGeoDataset);
flag = flag8;
if (!flag8)
{
strs.Add(rasterLayerClass.Name);
}
this.AddLayer(map, rasterLayerClass, ref envelope, flag);
}
}
else if (item.Type == esriDatasetType.esriDTTable)
{
try
{
IStandaloneTableCollection standaloneTableCollection = this.GetMap() as IStandaloneTableCollection;
IPropertySet connectionProperties = item.Workspace.ConnectionProperties;
bool flag9 = false;
int num = 0;
while (true)
{
if (num < standaloneTableCollection.StandaloneTableCount)
{
ITable table = standaloneTableCollection.StandaloneTable[num].Table;
if (!connectionProperties.IsEqual((table as IDataset).Workspace.ConnectionProperties) || !((table as IDataset).Name == item.Name))
{
num++;
}
else
{
flag9 = true;
break;
}
}
else
{
break;
}
}
if (!flag9)
{
standaloneTableCollection.AddStandaloneTable(new StandaloneTableClass()
{
Table = item as ITable
});
}
}
catch (Exception exception)
{
CErrorLog.writeErrorLog(this, exception, "");
}
}
else if (item.Type == esriDatasetType.esriDTGeometricNetwork)
{
IGeometricNetwork geometricNetwork = item as IGeometricNetwork;
if (geometricNetwork != null)
{
IEnumFeatureClass classesByType = geometricNetwork.ClassesByType[esriFeatureType.esriFTSimpleJunction];
classesByType.Reset();
for (n = classesByType.Next(); n != null; n = classesByType.Next())
{
featureLayerClass = new FeatureLayerClass()
{
FeatureClass = n,
Name = (n as IDataset).Name
};
this.AddLayer(map, featureLayerClass, ref envelope, true);
}
classesByType = geometricNetwork.ClassesByType[esriFeatureType.esriFTComplexJunction];
classesByType.Reset();
for (n = classesByType.Next(); n != null; n = classesByType.Next())
{
featureLayerClass = new FeatureLayerClass()
{
FeatureClass = n,
Name = (n as IDataset).Name
};
this.AddLayer(map, featureLayerClass, ref envelope, true);
}
classesByType = geometricNetwork.ClassesByType[esriFeatureType.esriFTSimpleEdge];
classesByType.Reset();
for (n = classesByType.Next(); n != null; n = classesByType.Next())
{
featureLayerClass = new FeatureLayerClass()
{
FeatureClass = n,
Name = (n as IDataset).Name
};
this.AddLayer(map, featureLayerClass, ref envelope, true);
}
classesByType = geometricNetwork.ClassesByType[esriFeatureType.esriFTComplexEdge];
classesByType.Reset();
for (n = classesByType.Next(); n != null; n = classesByType.Next())
{
featureLayerClass = new FeatureLayerClass()
{
FeatureClass = n,
Name = (n as IDataset).Name
};
this.AddLayer(map, featureLayerClass, ref envelope, true);
}
}
}
else if (item.Type == esriDatasetType.esriDTNetworkDataset)
{
INetworkLayer networkLayerClass = new NetworkLayerClass()
{
NetworkDataset = item as INetworkDataset
};
this.AddLayer(map, networkLayerClass as ILayer, ref envelope, true);
if (MessageBox.Show(string.Concat("是否将参加网络要素集-", item.Name, "-的所有要素添加到地图中"), "添加拓扑层", MessageBoxButtons.YesNo, MessageBoxIcon.Asterisk) == DialogResult.Yes)
{
classes = (item as IFeatureClassContainer).Classes;
classes.Reset();
for (m = classes.Next(); m != null; m = classes.Next())
{
cadFeatureLayerClass = new FeatureLayerClass()
{
FeatureClass = m,
Name = m.AliasName
};
this.AddLayer(map, cadFeatureLayerClass, ref envelope, true);
}
}
}
}
}
else
{
IMapServerLayer mapServerLayerClass = new MapServerLayerClass();
mapServerLayerClass.ServerConnect((objs[k] as IGxAGSObject).AGSServerObjectName, (objs[k] as IGxAGSObject).DefaultMapName);
this.AddLayer(map, mapServerLayerClass as ILayer, ref envelope, false);
}
}
processAssist.End();
bool layerCount = this.GetMap().LayerCount > 0;
if (strs.Count > 0)
{
MessageBox.Show("警告：数据范围不一致。\r\n 一个或多个添加的图层范围与关联的空间坐标系范围不一致。请检查数据问题。存在问题图层信息请查看错误日志!", "管理平台", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
StringBuilder stringBuilder = new StringBuilder();
foreach (string str1 in strs)
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(",");
}
stringBuilder.Append(str1);
}
CErrorLog.writeErrorLog(stringBuilder, null, "图层范围不一致!");
}
foreach (ILayer list0 in this.list_0)
{
list0.Visible = true;
}
if (layerCount && envelope != null)
{
IMap map1 = this.GetMap();
ISpatialReference spatialReference = map1.SpatialReference;
if ((spatialReference is IUnknownCoordinateSystem || envelope.SpatialReference is IUnknownCoordinateSystem || envelope.SpatialReference == null ? false : spatialReference != null))
{
envelope.Project(spatialReference);
}
(map1 as IActiveView).Extent = envelope;
(map1 as IActiveView).Refresh();
}
if (this.m_pApp != null)
{
this.m_pApp.MapDocumentChanged();
}
else if (ApplicationRef.Application != null)
{
ApplicationRef.Application.MapDocumentChanged();
}
}
catch (Exception exception1)
{
str = exception1.ToString();
}
if (this.onLoadCompleteHand_0 != null)
{
this.onLoadCompleteHand_0();
}
}
public override bool Pretreat()
{
try
{
//SendMessage(enumMessageType.RuleError, "正在准备数据");
IFeatureWorkspace fws = m_TopoWorkspace as IFeatureWorkspace;
IWorkspace2 ws2 = m_TopoWorkspace as IWorkspace2;
IFeatureClassContainer fClassContainer = this.m_Topology as IFeatureClassContainer;
IEnumFeatureClass enFeatureClass = fClassContainer.Classes;
IFeatureClass fClass = enFeatureClass.Next();
IFeatureClass fClassRefer = null;
bool isAdded = false;
while (fClass != null)
{
IDataset ds = fClass as IDataset;
if (ds.Name == m_LayerName)
{
isAdded = true;
break;
}
fClass = enFeatureClass.Next();
}
if (!isAdded)
{
if (!ws2.get_NameExists(esriDatasetType.esriDTFeatureClass, m_LayerName))
{
SendMessage(enumMessageType.RuleError, string.Format("图层{0}导入拓扑库失败，无法检查", this.m_psRuleParas.arraySeledLayers[0]));
return(false);
}
fClass = fws.OpenFeatureClass(m_LayerName);
this.m_Topology.AddClass(fClass as IClass, 1, m_psRuleParas.arrayRanks[0], 1, false);
}
if (this.m_psRuleParas.arraySeledLayers.Count > 1)
{
enFeatureClass.Reset();
fClassRefer = enFeatureClass.Next();
isAdded = false;
while (fClass != null)
{
IDataset ds = fClassRefer as IDataset;
if (ds.Name == m_ReferLayerName)
{
isAdded = true;
break;
}
fClassRefer = enFeatureClass.Next();
}
if (!isAdded)
{
if (!ws2.get_NameExists(esriDatasetType.esriDTFeatureClass, m_ReferLayerName))
{
SendMessage(enumMessageType.RuleError, string.Format("图层{0}不存在，无法检查", this.m_psRuleParas.arraySeledLayers[1]));
return(false);
}
fClassRefer = fws.OpenFeatureClass(m_ReferLayerName);
this.m_Topology.AddClass(fClass as IClass, 1, m_psRuleParas.arrayRanks[1], 1, false);
}
}
m_TopologylRule = new TopologyRuleClass();
m_TopologylRule.Name = m_psRuleParas.arrayRules[0].strRuleAliasName;
m_TopologylRule.OriginClassID = fClass.ObjectClassID;
if (fClassRefer != null)
{
m_TopologylRule.DestinationClassID = fClassRefer.ObjectClassID;
}
m_TopologylRule.AllOriginSubtypes = true;
m_TopologylRule.AllDestinationSubtypes = true;
m_TopologylRule.TopologyRuleType = GetTopologyTypeByName(m_psRuleParas.arrayRules[0].strTopoRuleName);
(this.m_Topology as ITopologyRuleContainer).AddRule(m_TopologylRule);
return(true);
}
catch (Exception exp)
{
SendMessage(enumMessageType.PretreatmentError, "加入到拓扑时出错，信息：" + exp.Message);
SendMessage(enumMessageType.Exception, exp.ToString());
return(false);
}
}
public void LoadData(IList ilist_0)
{
try
{
List <ILayer> list = new List <ILayer>();
for (int i = 0; i < ilist_0.Count; i++)
{
if (ilist_0[i] is IGxLayer)
{
list.Add((ilist_0[i] as IGxLayer).Layer);
}
else
{
IGxDataset gxDataset = ilist_0[i] as IGxDataset;
if (gxDataset != null)
{
IDataset dataset = gxDataset.Dataset;
if (dataset != null)
{
if (dataset.Type == esriDatasetType.esriDTFeatureClass)
{
IFeatureClass featureClass = (IFeatureClass)dataset;
IFeatureLayer featureLayer;
if ((gxDataset as IGxObject).Category.IndexOf("CAD") != -1)
{
if (featureClass.FeatureType == esriFeatureType.esriFTCoverageAnnotation)
{
featureLayer = new CadAnnotationLayer() as IFeatureLayer;
}
else
{
featureLayer = new CadFeatureLayer() as IFeatureLayer;
}
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
else if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
featureLayer = new FDOGraphicsLayer() as IFeatureLayer;
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
else if (featureClass.FeatureType == esriFeatureType.esriFTDimension)
{
featureLayer = new DimensionLayer() as IFeatureLayer;
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
else
{
featureLayer = new FeatureLayer();
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
list.Add(featureLayer);
}
else if (dataset.Type == esriDatasetType.esriDTCadDrawing)
{
if ((gxDataset as IGxObject).Category == "CAD绘图")
{
ICadLayer item = new CadLayer() as ICadLayer;
item.CadDrawingDataset = gxDataset.Dataset as ICadDrawingDataset;
item.Name = gxDataset.Dataset.Name;
list.Add(item);
}
else
{
IEnumGxObject children = (gxDataset as IGxObjectContainer).Children;
children.Reset();
for (IGxDataset gxDataset2 = children.Next() as IGxDataset; gxDataset2 != null; gxDataset2 = (children.Next() as IGxDataset))
{
IFeatureClass featureClass = gxDataset2.Dataset as IFeatureClass;
if (featureClass != null)
{
IFeatureLayer featureLayer;
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
featureLayer = new FDOGraphicsLayer() as IFeatureLayer;
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
else
{
featureLayer = new CadFeatureLayer() as IFeatureLayer;
featureLayer.FeatureClass = featureClass;
featureLayer.Name = featureClass.AliasName;
}
list.Add(featureLayer);
}
}
}
}
else if (dataset.Type == esriDatasetType.esriDTFeatureDataset)
{
IEnumDataset subsets = dataset.Subsets;
subsets.Reset();
for (IDataset dataset2 = subsets.Next(); dataset2 != null; dataset2 = subsets.Next())
{
if (dataset2.Type == esriDatasetType.esriDTFeatureClass)
{
IFeatureClass featureClass = dataset2 as IFeatureClass;
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
IFeatureLayer item = new FDOGraphicsLayer() as IFeatureLayer;
item.FeatureClass = featureClass;
item.Name = featureClass.AliasName;
list.Add(item);
}
else
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass,
Name = featureClass.AliasName
});
}
}
else if (dataset2.Type == esriDatasetType.esriDTTopology)
{
ITopologyLayer topologyLayer = new TopologyLayer() as ITopologyLayer;
topologyLayer.Topology = (dataset2 as ITopology);
(topologyLayer as ILayer).Name = dataset2.Name;
list.Add(topologyLayer as ILayer);
}
}
}
else if (dataset.Type == esriDatasetType.esriDTTopology)
{
if (System.Windows.Forms.MessageBox.Show("是否将参加拓扑-" + dataset.Name + "-的所有要素添加到地图中", "添加拓扑层", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Asterisk) == System.Windows.Forms.DialogResult.Yes)
{
IEnumFeatureClass classes = (dataset as IFeatureClassContainer).Classes;
classes.Reset();
for (IFeatureClass featureClass2 = classes.Next(); featureClass2 != null; featureClass2 = classes.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass2,
Name = featureClass2.AliasName
});
}
}
ITopologyLayer topologyLayer = new TopologyLayer() as ITopologyLayer;
topologyLayer.Topology = (dataset as ITopology);
(topologyLayer as ILayer).Name = dataset.Name;
list.Add(topologyLayer as ILayer);
}
else if (dataset.Type == esriDatasetType.esriDTTin)
{
list.Add(new TinLayer
{
Dataset = (ITin)dataset,
Name = dataset.Name
});
}
else if (dataset.Type == esriDatasetType.esriDTRasterDataset || dataset.Type == esriDatasetType.esriDTRasterBand)
{
bool flag = true;
if (!((IRasterPyramid)dataset).Present)
{
if (ApplicationRef.PyramidPromptType == PyramidPromptType.AlwaysBuildNoPrompt)
{
((IRasterPyramid)dataset).Create();
}
else if (ApplicationRef.PyramidPromptType == PyramidPromptType.AlwaysPrompt)
{
System.Windows.Forms.DialogResult dialogResult = BuildPyramidSet.Show();
if (dialogResult == System.Windows.Forms.DialogResult.Yes)
{
((IRasterPyramid)dataset).Create();
}
else if (dialogResult == System.Windows.Forms.DialogResult.Cancel)
{
flag = false;
}
}
}
if (flag)
{
IRasterLayer rasterLayer = new RasterLayer
{
Cached = true
};
rasterLayer.CreateFromDataset((IRasterDataset)dataset);
rasterLayer.Name = dataset.Name;
list.Add(rasterLayer);
}
}
else
{
if (dataset.Type == esriDatasetType.esriDTTable)
{
try
{
IRasterCatalogTable rasterCatalogTable = new RasterCatalogTable();
rasterCatalogTable.Table = (ITable)dataset;
rasterCatalogTable.Update();
IRasterCatalogLayer rasterCatalogLayer = new RasterCatalogLayer() as IRasterCatalogLayer;
rasterCatalogLayer.Create(rasterCatalogTable);
rasterCatalogLayer.Name = dataset.BrowseName;
list.Add(rasterCatalogLayer);
goto IL_8B0;
}
catch (Exception ex)
{
try
{
IStandaloneTableCollection standaloneTableCollection = this.method_0() as IStandaloneTableCollection;
IPropertySet connectionProperties = dataset.Workspace.ConnectionProperties;
bool flag2 = false;
for (int j = 0; j < standaloneTableCollection.StandaloneTableCount; j++)
{
ITable table = standaloneTableCollection.get_StandaloneTable(j).Table;
if (
connectionProperties.IsEqual(
(table as IDataset).Workspace.ConnectionProperties) &&
(table as IDataset).Name == dataset.Name)
{
flag2 = true;
}
else
{
standaloneTableCollection.AddStandaloneTable(new StandaloneTable
{
Table = dataset as ITable
});
}
}
}
catch (Exception exception_)
{
CErrorLog.writeErrorLog(this, exception_, "");
}
goto IL_8B0;
}
}
if (dataset.Type == esriDatasetType.esriDTGeometricNetwork)
{
IGeometricNetwork geometricNetwork = dataset as IGeometricNetwork;
if (geometricNetwork != null)
{
IEnumFeatureClass enumFeatureClass = geometricNetwork.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
enumFeatureClass.Reset();
for (IFeatureClass featureClass3 = enumFeatureClass.Next(); featureClass3 != null; featureClass3 = enumFeatureClass.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass3,
Name = (featureClass3 as IDataset).Name
});
}
enumFeatureClass = geometricNetwork.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
enumFeatureClass.Reset();
for (IFeatureClass featureClass3 = enumFeatureClass.Next(); featureClass3 != null; featureClass3 = enumFeatureClass.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass3,
Name = (featureClass3 as IDataset).Name
});
}
enumFeatureClass = geometricNetwork.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
enumFeatureClass.Reset();
for (IFeatureClass featureClass3 = enumFeatureClass.Next(); featureClass3 != null; featureClass3 = enumFeatureClass.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass3,
Name = (featureClass3 as IDataset).Name
});
}
enumFeatureClass = geometricNetwork.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
enumFeatureClass.Reset();
for (IFeatureClass featureClass3 = enumFeatureClass.Next(); featureClass3 != null; featureClass3 = enumFeatureClass.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass3,
Name = (featureClass3 as IDataset).Name
});
}
}
}
else if (dataset.Type == esriDatasetType.esriDTNetworkDataset)
{
INetworkDataset networkDataset = dataset as INetworkDataset;
INetworkLayer item = new NetworkLayer() as INetworkLayer;
item.NetworkDataset = networkDataset;
list.Add(item as ILayer);
if (System.Windows.Forms.MessageBox.Show("是否将参加网络要素集-" + dataset.Name + "-的所有要素添加到地图中", "添加拓扑层", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Asterisk) == System.Windows.Forms.DialogResult.Yes)
{
IEnumFeatureClass classes = (dataset as IFeatureClassContainer).Classes;
classes.Reset();
for (IFeatureClass featureClass2 = classes.Next(); featureClass2 != null; featureClass2 = classes.Next())
{
list.Add(new FeatureLayer
{
FeatureClass = featureClass2,
Name = featureClass2.AliasName
});
}
}
}
}
}
}
}
IL_8B0 :;
}
int num = list.Count;
ILayer layer = null;
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IRasterCatalogLayer)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IRasterLayer)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is ITinLayer)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is ICadLayer)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
if (featureClass.ShapeType == esriGeometryType.esriGeometryPolygon || featureClass.ShapeType == esriGeometryType.esriGeometryEnvelope)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
if (featureClass.ShapeType == esriGeometryType.esriGeometryLine || featureClass.ShapeType == esriGeometryType.esriGeometryBezier3Curve || featureClass.ShapeType == esriGeometryType.esriGeometryCircularArc || featureClass.ShapeType == esriGeometryType.esriGeometryEllipticArc || featureClass.ShapeType == esriGeometryType.esriGeometryPath || featureClass.ShapeType == esriGeometryType.esriGeometryPolyline)
{
try
{
this.method_0().AddLayer(layer);
goto IL_B56;
}
catch
{
goto IL_B56;
}
goto IL_B4D;
IL_B56:
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
IL_B4D :;
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
if (layer is IFeatureLayer)
{
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
if (featureClass.ShapeType == esriGeometryType.esriGeometryMultipoint || featureClass.ShapeType == esriGeometryType.esriGeometryPoint)
{
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
}
for (int i = num - 1; i >= 0; i--)
{
layer = list[i];
this.method_0().AddLayer(layer);
(this.method_0() as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGeography, layer, null);
list.RemoveAt(i);
num--;
}
}
catch (Exception ex)
{
ex.ToString();
}
}
private void Init()
{
IEnumNetWeightAssociation association;
INetWeightAssociation association2;
this.m_CanDo = false;
this.cboJunWeight.Properties.Items.Clear();
this.cbofromToEdgeWeight.Properties.Items.Clear();
this.cboToFromEdgeWeight.Properties.Items.Clear();
this.cboJunWeight.Properties.Items.Add("<无>");
this.cbofromToEdgeWeight.Properties.Items.Add("<无>");
this.cboToFromEdgeWeight.Properties.Items.Add("<无>");
int num = 0;
int num2 = 0;
int num3 = 0;
INetSchema network = NetworkAnalyst.m_pAnalystGN.Network as INetSchema;
IEnumFeatureClass class2 =
NetworkAnalyst.m_pAnalystGN.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
class2.Reset();
IFeatureClass class3 = class2.Next();
IList list = new ArrayList();
while (class3 != null)
{
association = network.get_WeightAssociationsByTableName(class3.AliasName);
association.Reset();
association2 = association.Next();
while (association2 != null)
{
if (list.IndexOf(association2.WeightID) == -1)
{
list.Add(association2.WeightID);
this.cboJunWeight.Properties.Items.Add(new WeightWrap(network.get_Weight(association2.WeightID)));
if ((NetworkAnalyst.JunctionWeight != null) &&
(association2.WeightID == NetworkAnalyst.JunctionWeight.WeightID))
{
num = this.cboJunWeight.Properties.Items.Count - 1;
}
}
association2 = association.Next();
}
class3 = class2.Next();
}
class2 = NetworkAnalyst.m_pAnalystGN.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
association = network.get_WeightAssociationsByTableName(class3.AliasName);
association.Reset();
association2 = association.Next();
while (association2 != null)
{
if (list.IndexOf(association2.WeightID) == -1)
{
list.Add(association2.WeightID);
this.cboJunWeight.Properties.Items.Add(new WeightWrap(network.get_Weight(association2.WeightID)));
if ((NetworkAnalyst.JunctionWeight != null) &&
(association2.WeightID == NetworkAnalyst.JunctionWeight.WeightID))
{
num = this.cboJunWeight.Properties.Items.Count - 1;
}
}
association2 = association.Next();
}
}
class2 = NetworkAnalyst.m_pAnalystGN.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
class2.Reset();
class3 = class2.Next();
list.Clear();
while (class3 != null)
{
association = network.get_WeightAssociationsByTableName(class3.AliasName);
association.Reset();
association2 = association.Next();
while (association2 != null)
{
if (list.IndexOf(association2.WeightID) == -1)
{
list.Add(association2.WeightID);
this.cbofromToEdgeWeight.Properties.Items.Add(
new WeightWrap(network.get_Weight(association2.WeightID)));
this.cboToFromEdgeWeight.Properties.Items.Add(
new WeightWrap(network.get_Weight(association2.WeightID)));
if ((NetworkAnalyst.FromToEdgeWeight != null) &&
(association2.WeightID == NetworkAnalyst.FromToEdgeWeight.WeightID))
{
num2 = this.cbofromToEdgeWeight.Properties.Items.Count - 1;
}
if ((NetworkAnalyst.ToFromEdgeWeight != null) &&
(association2.WeightID == NetworkAnalyst.ToFromEdgeWeight.WeightID))
{
num3 = this.cboToFromEdgeWeight.Properties.Items.Count - 1;
}
}
association2 = association.Next();
}
class3 = class2.Next();
}
class2 = NetworkAnalyst.m_pAnalystGN.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
association = network.get_WeightAssociationsByTableName(class3.AliasName);
association.Reset();
for (association2 = association.Next(); association2 != null; association2 = association.Next())
{
if (list.IndexOf(association2.WeightID) == -1)
{
list.Add(association2.WeightID);
this.cbofromToEdgeWeight.Properties.Items.Add(
new WeightWrap(network.get_Weight(association2.WeightID)));
this.cboToFromEdgeWeight.Properties.Items.Add(
new WeightWrap(network.get_Weight(association2.WeightID)));
if ((NetworkAnalyst.FromToEdgeWeight != null) &&
(association2.WeightID == NetworkAnalyst.FromToEdgeWeight.WeightID))
{
num2 = this.cbofromToEdgeWeight.Properties.Items.Count - 1;
}
if ((NetworkAnalyst.ToFromEdgeWeight != null) &&
(association2.WeightID == NetworkAnalyst.ToFromEdgeWeight.WeightID))
{
num3 = this.cboToFromEdgeWeight.Properties.Items.Count - 1;
}
}
}
}
this.cboJunWeight.SelectedIndex = num;
this.cbofromToEdgeWeight.SelectedIndex = num2;
this.cboToFromEdgeWeight.SelectedIndex = num3;
this.m_CanDo = true;
}
private void Init()
{
IEnumNetWeightAssociation association;
INetWeightAssociation association2;
string str;
int num4;
this.m_CanDo = false;
this.cboJunWeight.Properties.Items.Clear();
this.cbofromToEdgeWeight.Properties.Items.Clear();
this.cboToFromEdgeWeight.Properties.Items.Clear();
this.cboJunWeight.Properties.Items.Add("<无>");
this.cbofromToEdgeWeight.Properties.Items.Add("<无>");
this.cboToFromEdgeWeight.Properties.Items.Add("<无>");
int num = 0;
int num2 = 0;
int num3 = 0;
INetSchema network = NetworkAnalyst.m_pAnalystGN.Network as INetSchema;
IEnumFeatureClass class2 =
NetworkAnalyst.m_pAnalystGN.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
class2.Reset();
IFeatureClass class3 = class2.Next();
IList list = new ArrayList();
while (class3 != null)
{
association = network.get_WeightAssociationsByTableName(class3.AliasName);
association.Reset();
association2 = association.Next();
while (association2 != null)
{
if (list.IndexOf(association2.WeightID) == -1)
{
list.Add(association2.WeightID);
this.cboJunWeight.Properties.Items.Add(new WeightWrap(network.get_Weight(association2.WeightID)));
if ((NetworkAnalyst.JunctionFilterWeight != null) &&
(association2.WeightID == NetworkAnalyst.JunctionFilterWeight.WeightID))
{
num = this.cboJunWeight.Properties.Items.Count - 1;
}
}
association2 = association.Next();
}
class3 = class2.Next();
}
class2 = NetworkAnalyst.m_pAnalystGN.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
association = network.get_WeightAssociationsByTableName(class3.AliasName);
association.Reset();
association2 = association.Next();
while (association2 != null)
{
if (list.IndexOf(association2.WeightID) == -1)
{
list.Add(association2.WeightID);
this.cboJunWeight.Properties.Items.Add(new WeightWrap(network.get_Weight(association2.WeightID)));
if ((NetworkAnalyst.JunctionFilterWeight != null) &&
(association2.WeightID == NetworkAnalyst.JunctionFilterWeight.WeightID))
{
num = this.cboJunWeight.Properties.Items.Count - 1;
}
}
association2 = association.Next();
}
}
class2 = NetworkAnalyst.m_pAnalystGN.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
class2.Reset();
class3 = class2.Next();
list.Clear();
while (class3 != null)
{
association = network.get_WeightAssociationsByTableName(class3.AliasName);
association.Reset();
association2 = association.Next();
while (association2 != null)
{
if (list.IndexOf(association2.WeightID) == -1)
{
list.Add(association2.WeightID);
this.cbofromToEdgeWeight.Properties.Items.Add(
new WeightWrap(network.get_Weight(association2.WeightID)));
this.cboToFromEdgeWeight.Properties.Items.Add(
new WeightWrap(network.get_Weight(association2.WeightID)));
if ((NetworkAnalyst.FromToEdgeFilterWeight != null) &&
(association2.WeightID == NetworkAnalyst.FromToEdgeFilterWeight.WeightID))
{
num2 = this.cbofromToEdgeWeight.Properties.Items.Count - 1;
}
if ((NetworkAnalyst.ToFromEdgeFilterWeight != null) &&
(association2.WeightID == NetworkAnalyst.ToFromEdgeFilterWeight.WeightID))
{
num3 = this.cboToFromEdgeWeight.Properties.Items.Count - 1;
}
}
association2 = association.Next();
}
class3 = class2.Next();
}
class2 = NetworkAnalyst.m_pAnalystGN.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
class2.Reset();
for (class3 = class2.Next(); class3 != null; class3 = class2.Next())
{
association = network.get_WeightAssociationsByTableName(class3.AliasName);
association.Reset();
for (association2 = association.Next(); association2 != null; association2 = association.Next())
{
if (list.IndexOf(association2.WeightID) == -1)
{
list.Add(association2.WeightID);
this.cbofromToEdgeWeight.Properties.Items.Add(
new WeightWrap(network.get_Weight(association2.WeightID)));
this.cboToFromEdgeWeight.Properties.Items.Add(
new WeightWrap(network.get_Weight(association2.WeightID)));
if ((NetworkAnalyst.FromToEdgeFilterWeight != null) &&
(association2.WeightID == NetworkAnalyst.FromToEdgeFilterWeight.WeightID))
{
num2 = this.cbofromToEdgeWeight.Properties.Items.Count - 1;
}
if ((NetworkAnalyst.ToFromEdgeFilterWeight != null) &&
(association2.WeightID == NetworkAnalyst.ToFromEdgeFilterWeight.WeightID))
{
num3 = this.cboToFromEdgeWeight.Properties.Items.Count - 1;
}
}
}
}
this.chkJunapplyNot.Checked = NetworkAnalyst.ApplyJuncFilterWeight;
this.chkEdgeapplyNot.Checked = NetworkAnalyst.ApplyEdgeFilterWeight;
this.cboJunWeight.SelectedIndex = num;
this.cbofromToEdgeWeight.SelectedIndex = num2;
this.cboToFromEdgeWeight.SelectedIndex = num3;
if (num == 0)
{
this.btnValiteJFWRange.Enabled = false;
this.txtJFWRange.Enabled = false;
}
if ((num2 == 0) || (num3 == 0))
{
this.btnValiateEFWRange.Enabled = false;
this.txtEFWRange.Enabled = false;
}
if (NetworkAnalyst.JuncfromValues != null)
{
if (NetworkAnalyst.JuncfromValues[0] == NetworkAnalyst.JunctoValues[0])
{
str = NetworkAnalyst.JuncfromValues[0].ToString();
}
else
{
str = NetworkAnalyst.JuncfromValues[0].ToString() + " - " +
NetworkAnalyst.JunctoValues[0].ToString();
}
for (num4 = 1; num4 < NetworkAnalyst.JuncfromValues.Length; num4++)
{
if (NetworkAnalyst.JuncfromValues[num4] == NetworkAnalyst.JunctoValues[num4])
{
str = str + " , " + NetworkAnalyst.JuncfromValues[0].ToString();
}
else
{
str = str + " , " + NetworkAnalyst.JuncfromValues[0].ToString() + " - " +
NetworkAnalyst.JunctoValues[0].ToString();
}
}
this.txtJFWRange.Text = str;
}
else
{
this.txtJFWRange.Text = "";
}
if (NetworkAnalyst.EdgefromValues != null)
{
if (NetworkAnalyst.EdgefromValues[0] == NetworkAnalyst.EdgetoValues[0])
{
str = NetworkAnalyst.EdgefromValues[0].ToString();
}
else
{
str = NetworkAnalyst.EdgefromValues[0].ToString() + " - " +
NetworkAnalyst.EdgetoValues[0].ToString();
}
for (num4 = 1; num4 < NetworkAnalyst.JuncfromValues.Length; num4++)
{
if (NetworkAnalyst.EdgefromValues[num4] == NetworkAnalyst.EdgetoValues[num4])
{
str = str + " , " + NetworkAnalyst.EdgefromValues[0].ToString();
}
else
{
str = str + " , " + NetworkAnalyst.EdgefromValues[0].ToString() + " - " +
NetworkAnalyst.EdgetoValues[0].ToString();
}
}
this.txtEFWRange.Text = str;
}
else
{
this.txtEFWRange.Text = "";
}
this.m_CanDo = true;
}
public static void AddDataset(IBasicMap ibasicMap_0, IDataset idataset_0, string string_0)
{
if (string_0 == null)
{
string_0 = "";
}
switch (idataset_0.Type)
{
case esriDatasetType.esriDTFeatureDataset:
{
IEnumDataset subsets = idataset_0.Subsets;
subsets.Reset();
for (IDataset dataset2 = subsets.Next(); dataset2 != null; dataset2 = subsets.Next())
{
AddDataset(ibasicMap_0, dataset2, string_0);
}
break;
}
case esriDatasetType.esriDTFeatureClass:
{
IFeatureLayer layer;
IFeatureClass class2 = (IFeatureClass)idataset_0;
if (class2.FeatureType != esriFeatureType.esriFTAnnotation)
{
if (class2.FeatureType == esriFeatureType.esriFTDimension)
{
IFeatureLayer dimensionLayer = new DimensionLayer() as IFeatureLayer;
dimensionLayer.FeatureClass = class2;
dimensionLayer.Name = string_0 + class2.AliasName;
layer = dimensionLayer as IFeatureLayer;
ibasicMap_0.AddLayer(layer);
}
else
{
layer = new FeatureLayer
{
FeatureClass = class2,
Name = string_0 + class2.AliasName
};
ibasicMap_0.AddLayer(layer);
}
break;
}
layer = new FDOGraphicsLayer() as IFeatureLayer;
try
{
layer.FeatureClass = class2;
layer.Name = string_0 + class2.AliasName;
ibasicMap_0.AddLayer(layer);
}
catch (Exception exception)
{
exception.ToString();
}
break;
}
case esriDatasetType.esriDTGeometricNetwork:
{
IGeometricNetwork network = idataset_0 as IGeometricNetwork;
if (network != null)
{
IFeatureLayer layer7;
IEnumFeatureClass class3 = network.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
class3.Reset();
IFeatureClass class4 = class3.Next();
while (class4 != null)
{
layer7 = new FeatureLayer
{
FeatureClass = class4,
Name = string_0 + (class4 as IDataset).Name
};
ibasicMap_0.AddLayer(layer7);
class4 = class3.Next();
}
class3 = network.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
class3.Reset();
for (class4 = class3.Next(); class4 != null; class4 = class3.Next())
{
layer7 = new FeatureLayer
{
FeatureClass = class4,
Name = string_0 + (class4 as IDataset).Name
};
ibasicMap_0.AddLayer(layer7);
}
class3 = network.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
class3.Reset();
for (class4 = class3.Next(); class4 != null; class4 = class3.Next())
{
layer7 = new FeatureLayer
{
FeatureClass = class4,
Name = string_0 + (class4 as IDataset).Name
};
ibasicMap_0.AddLayer(layer7);
}
class3 = network.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
class3.Reset();
for (class4 = class3.Next(); class4 != null; class4 = class3.Next())
{
layer7 = new FeatureLayer
{
FeatureClass = class4,
Name = string_0 + (class4 as IDataset).Name
};
ibasicMap_0.AddLayer(layer7);
}
}
break;
}
case esriDatasetType.esriDTTopology:
{
ITopologyLayer layer = new TopologyLayer() as ITopologyLayer;
layer.Topology = idataset_0 as ITopology;
ITopologyLayer layer3 = layer as ITopologyLayer;
(layer3 as ILayer).Name = string_0 + idataset_0.Name;
ibasicMap_0.AddLayer(layer3 as ILayer);
break;
}
case esriDatasetType.esriDTTable:
try
{
IRasterCatalogTable pCatalog = new RasterCatalogTable
{
Table = (ITable)idataset_0
};
pCatalog.Update();
IRasterCatalogLayer pLayer = new RasterCatalogLayer() as IRasterCatalogLayer;
pLayer.Create(pCatalog);
pLayer.Name = string_0 + idataset_0.BrowseName;
ibasicMap_0.AddLayer(pLayer);
}
catch
{
try
{
IStandaloneTableCollection tables = ibasicMap_0 as IStandaloneTableCollection;
IPropertySet connectionProperties = idataset_0.Workspace.ConnectionProperties;
bool flag = false;
for (int i = 0; i < tables.StandaloneTableCount; i++)
{
ITable table = tables.get_StandaloneTable(i).Table;
if (connectionProperties.IsEqual((table as IDataset).Workspace.ConnectionProperties) &&
((table as IDataset).Name == idataset_0.Name))
{
goto Label_03E1;
}
}
goto Label_03E4;
Label_03E1:
flag = true;
Label_03E4:
if (!flag)
{
IStandaloneTable table3 = new StandaloneTable
{
Table = idataset_0 as ITable
};
tables.AddStandaloneTable(table3);
}
}
catch (Exception exception2)
{
CErrorLog.writeErrorLog(null, exception2, "");
}
}
break;
case esriDatasetType.esriDTRasterDataset:
case esriDatasetType.esriDTRasterBand:
{
IRasterLayer layer5 = new RasterLayer();
layer5.CreateFromDataset((IRasterDataset)idataset_0);
layer5.Name = string_0 + idataset_0.Name;
ibasicMap_0.AddLayer(layer5);
break;
}
case esriDatasetType.esriDTTin:
{
ITinLayer layer4 = new TinLayer
{
Dataset = (ITin)idataset_0,
Name = string_0 + idataset_0.Name
};
ibasicMap_0.AddLayer(layer4);
break;
}
case esriDatasetType.esriDTCadDrawing:
{
ICadLayer layer2 = new CadLayer() as ICadLayer;
layer2.CadDrawingDataset = idataset_0 as ICadDrawingDataset;
layer2.Name = idataset_0.Name;
ibasicMap_0.AddLayer(layer2);
break;
}
}
}
