public GeometricNetwork(GeometricNetwork prototype) : base(prototype)
{
if (prototype.Extent != null)
{
this._extent = prototype.Extent.Clone() as Extent;
}
if (prototype.SpatialReference != null)
{
this._spatialReference = prototype.SpatialReference.Clone() as SpatialReference;
}
this._networkType = prototype.NetworkType;
this._orphanJunctionFeatureClassName = prototype.OrphanJunctionFeatureClassName;
// Add Cloned Rules
this._connectivityRules = new List <ConnectivityRule>();
foreach (ConnectivityRule connnectivityRule in prototype.ConnectivityRules)
{
this._connectivityRules.Add((ConnectivityRule)connnectivityRule.Clone());
}
// Add Cloned Network Weights
this._netWeights = new List <NetWeight>();
foreach (NetWeight netWeight in prototype.NetworkWeights)
{
this._netWeights.Add((NetWeight)netWeight.Clone());
}
// Add Cloned Network Weight Associations
this._netWeightAssociations = new List <NetWeightAssociation>();
foreach (NetWeightAssociation netWeightAssociation in prototype.NetworkWeightAssociations)
{
this._netWeightAssociations.Add((NetWeightAssociation)netWeightAssociation.Clone());
}
}
//
// CONSTRUCTOR
//
public TabbedDocumentGeometricNetwork(GeometricNetwork geometricNetwork) {
InitializeComponent();
this.geometricNetworkModel1.GeometricNetwork = geometricNetwork;
this.geometricNetworkModel1.OpenModel();
this.TabText = geometricNetwork.Name;
this.TabImage = this.geometricNetworkModel1.Icon;
}
//
// CONSTRUCTOR
//
public TabbedDocumentGeometricNetworkEJ(GeometricNetwork geometricNetwork) {
InitializeComponent();
this.geometricNetworkModelEJ1.GeometricNetwork = geometricNetwork;
this.geometricNetworkModelEJ1.OpenModel();
this.TabText = string.Format("{0} {1}", geometricNetwork.Name, "(EJ Rules)");
this.TabImage = this.geometricNetworkModelEJ1.Icon;
}
//
// PUBLIC METHODS
//
public override void OpenModel(string filename) {
// Exit if FileName is invalid
if (string.IsNullOrEmpty(filename)) { return; }
// Exit if File does not exist
if (!File.Exists(filename)) { return; }
// Open XML Workspace
XPathDocument document = null;
try {
document = new XPathDocument(filename, XmlSpace.None);
}
catch (XmlException ex) {
MessageBox.Show(
"The XML file failed to load. Please select 'View > Exceptions' to view a detailed explanation.",
Resources.TEXT_APPLICATION,
MessageBoxButtons.OK,
MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1,
MessageBoxOptions.DefaultDesktopOnly);
// Add Exception
ExceptionDialog.HandleException(ex);
}
if (document == null) { return; }
// Get XPathNavigator (IXPathNavigable::CreateNavigator)
XPathNavigator navigator = document.CreateNavigator();
// Get <esri:Workspace>
if (!navigator.MoveToFirstChild()) {
MessageBox.Show(
"This file is not a valid ESRI xml workspace document",
Resources.TEXT_APPLICATION,
MessageBoxButtons.OK,
MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1,
MessageBoxOptions.DefaultDesktopOnly);
return;
}
// Check Node Name
if (navigator.Name != "esri:Workspace") {
MessageBox.Show(
"This file is not a valid ESRI xml workspace document",
Resources.TEXT_APPLICATION,
MessageBoxButtons.OK,
MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1,
MessageBoxOptions.DefaultDesktopOnly);
return;
}
// Create Xml Namespace Manager
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(navigator.NameTable);
namespaceManager.AddNamespace(Xml._XSI, Xml.XMLSCHEMAINSTANCE);
// Suspend Model
this.Suspend();
this.SuspendEvents = true;
if (ModelSettings.Default.EnableUndoRedo) {
this.UndoList.Suspend();
}
// Select Domains
XPathNodeIterator iteratorDomain = navigator.Select("WorkspaceDefinition/Domains/Domain");
// Add Domains
while (iteratorDomain.MoveNext()) {
XPathNavigator domain = iteratorDomain.Current;
XPathNavigator type = domain.SelectSingleNode(Xml._XSITYPE, namespaceManager);
switch (type.Value) {
case Xml._RANGEDOMAIN:
DomainRange domainRange = new DomainRange(domain);
this.Shapes.Add(this.Shapes.CreateKey(), domainRange);
break;
case Xml._CODEDVALUEDOMAIN:
DomainCodedValue domainCodedValue = new DomainCodedValue(domain);
this.Shapes.Add(this.Shapes.CreateKey(), domainCodedValue);
break;
}
}
// Select Root DataElements
XPathNodeIterator iteratorDataElement = navigator.Select("WorkspaceDefinition/DatasetDefinitions/DataElement");
while (iteratorDataElement.MoveNext()) {
XPathNavigator dataElement = iteratorDataElement.Current;
XPathNavigator type = dataElement.SelectSingleNode(Xml._XSITYPE, namespaceManager);
switch (type.Value) {
case Xml._DEFEATUREDATASET:
// Create FeatureDataset
FeatureDataset featureDataset = new FeatureDataset(dataElement);
this.Shapes.Add(this.Shapes.CreateKey(), featureDataset);
// Loop for Child DataElements
XPathNodeIterator iteratorDataElement2 = dataElement.Select("Children/DataElement");
while (iteratorDataElement2.MoveNext()) {
XPathNavigator dataElement2 = iteratorDataElement2.Current;
XPathNavigator type2 = dataElement2.SelectSingleNode(Xml._XSITYPE, namespaceManager);
switch (type2.Value) {
case Xml._DEFEATURECLASS:
// Create FeatureClass
FeatureClass featureClass2 = new FeatureClass(dataElement2);
this.Shapes.Add(this.Shapes.CreateKey(), featureClass2);
// Create Link to FeatureDataset
Link link1 = new Link(featureDataset, featureClass2);
link1.BorderColor = ModelSettings.Default.EnabledLines;
link1.BorderStyle = DashStyle.Solid;
link1.BorderWidth = 1f;
link1.End.Marker.BorderColor = ModelSettings.Default.EnabledLines;
this.Lines.Add(this.Lines.CreateKey(), link1);
// Add Subtypes
this.AddSubtypes(featureClass2, dataElement2);
break;
case Xml._DEGEOMETRICNETWORK:
// Create GeometricNetwork
GeometricNetwork geometricNetwork = new GeometricNetwork(dataElement2);
this.Shapes.Add(this.Shapes.CreateKey(), geometricNetwork);
// Create Link to FeatureDataset
Link link2 = new Link(featureDataset, geometricNetwork);
link2.BorderColor = ModelSettings.Default.EnabledLines;
link2.BorderStyle = DashStyle.Solid;
link2.BorderWidth = 1f;
link2.End.Marker.BorderColor = ModelSettings.Default.EnabledLines;
this.Lines.Add(this.Lines.CreateKey(), link2);
break;
case Xml._DERELATIONSHIPCLASS:
// Create Relationship
RelationshipClass relationshipClass = new RelationshipClass(dataElement2);
this.Shapes.Add(this.Shapes.CreateKey(), relationshipClass);
// Create Link to FeatureDataset
Link link3 = new Link(featureDataset, relationshipClass);
link3.BorderColor = ModelSettings.Default.EnabledLines;
link3.BorderStyle = DashStyle.Solid;
link3.BorderWidth = 1f;
link3.End.Marker.BorderColor = ModelSettings.Default.EnabledLines;
this.Lines.Add(this.Lines.CreateKey(), link3);
break;
case Xml._DETOPOLOGY:
// Create Topology
Topology topology = new Topology(dataElement2);
this.Shapes.Add(this.Shapes.CreateKey(), topology);
// Create Link to FeatureDataset
Link link4 = new Link(featureDataset, topology);
link4.BorderColor = ModelSettings.Default.EnabledLines;
link4.BorderStyle = DashStyle.Solid;
link4.BorderWidth = 1f;
link4.End.Marker.BorderColor = ModelSettings.Default.EnabledLines;
this.Lines.Add(this.Lines.CreateKey(), link4);
break;
case Xml._DENETWORKDATASET:
// Create Network Dataset
Network network = new Network(dataElement2);
this.Shapes.Add(this.Shapes.CreateKey(), network);
// Create Link to FeatureDataset
Link link5 = new Link(featureDataset, network);
link5.BorderColor = ModelSettings.Default.EnabledLines;
link5.BorderStyle = DashStyle.Solid;
link5.BorderWidth = 1f;
link5.End.Marker.BorderColor = ModelSettings.Default.EnabledLines;
this.Lines.Add(this.Lines.CreateKey(), link5);
break;
case Xml._DETERRAIN:
// Create Network Dataset
Terrain terrain = new Terrain(dataElement2);
this.Shapes.Add(this.Shapes.CreateKey(), terrain);
// Create Link to FeatureDataset
Link link6 = new Link(featureDataset, terrain);
link6.BorderColor = ModelSettings.Default.EnabledLines;
link6.BorderStyle = DashStyle.Solid;
link6.BorderWidth = 1f;
link6.End.Marker.BorderColor = ModelSettings.Default.EnabledLines;
this.Lines.Add(this.Lines.CreateKey(), link6);
break;
}
}
break;
case Xml._DEFEATURECLASS:
// Create FeatureClass
FeatureClass featureClass = new FeatureClass(dataElement);
this.Shapes.Add(this.Shapes.CreateKey(), featureClass);
// Add Subtypes
this.AddSubtypes(featureClass, dataElement);
break;
case Xml._DETABLE:
// Create Table
ObjectClass objectClass = new ObjectClass(dataElement);
this.Shapes.Add(this.Shapes.CreateKey(), objectClass);
// Add Subtypes
this.AddSubtypes(objectClass, dataElement);
break;
case Xml._DERASTERCATALOG:
// Create Table
RasterCatalog rasterCatalog = new RasterCatalog(dataElement);
this.Shapes.Add(this.Shapes.CreateKey(), rasterCatalog);
break;
case Xml._DERELATIONSHIPCLASS:
// Create Relationship
RelationshipClass relationshipClass2 = new RelationshipClass(dataElement);
this.Shapes.Add(this.Shapes.CreateKey(), relationshipClass2);
break;
case Xml._DERASTERDATASET:
// Create RasterDataset
RasterDataset rasterDataset = new RasterDataset(dataElement);
this.Shapes.Add(this.Shapes.CreateKey(), rasterDataset);
// Loop for Child DataElements
XPathNodeIterator iteratorDataElement3 = dataElement.Select("Children/DataElement");
while (iteratorDataElement3.MoveNext()) {
XPathNavigator dataElement2 = iteratorDataElement3.Current;
XPathNavigator type2 = dataElement2.SelectSingleNode(Xml._XSITYPE, namespaceManager);
switch (type2.Value) {
case Xml._DERASTERBAND:
// Create FeatureClass
RasterBand rasterBand = new RasterBand(dataElement2);
this.Shapes.Add(this.Shapes.CreateKey(), rasterBand);
// Create Link to FeatureDataset
Link link = new Link(rasterDataset, rasterBand);
link.BorderColor = ModelSettings.Default.EnabledLines;
link.BorderStyle = DashStyle.Solid;
link.BorderWidth = 1f;
link.End.Marker.BorderColor = ModelSettings.Default.EnabledLines;
this.Lines.Add(this.Lines.CreateKey(), link);
break;
}
}
break;
}
}
// <esri:Workspace><WorkspaceDefinition><Metadata><XmlDoc>
XPathNavigator navigatorMetadata = navigator.SelectSingleNode("WorkspaceDefinition/Metadata/XmlDoc");
if (navigatorMetadata != null) {
this._metadata = navigatorMetadata.Value;
}
// <WorkspaceType>
XPathNavigator navigatorWorkspaceType = navigator.SelectSingleNode("WorkspaceDefinition/WorkspaceType");
if (navigatorWorkspaceType != null) {
this._workspaceType = (esriWorkspaceType)Enum.Parse(typeof(esriWorkspaceType), navigatorWorkspaceType.Value, true);
}
// <Version>
XPathNavigator navigatorVersion = navigator.SelectSingleNode("WorkspaceDefinition/Version");
if (navigatorVersion != null) {
this._version = navigatorVersion.Value;
}
// Close XML Document
document = null;
// Perform Layout
this.ExecuteLayout(typeof(HierarchicalLayout), true);
// Resume and Refresh Model
if (ModelSettings.Default.EnableUndoRedo) {
this.UndoList.Resume();
}
this.SuspendEvents = false;
this.Resume();
this.Refresh();
// Make Dirty
this._dirty = true;
}
private void Model_ElementInvalid(object sender, ElementEventArgs e)
{
// Exit if GeometricNetwork Does not Exist
if (this._geometricNetwork == null)
{
return;
}
// Get Element
Element element = e.Value;
if (element == null)
{
return;
}
EsriLine <GeometricNetworkControllerMembership> line = element as EsriLine <GeometricNetworkControllerMembership>;
if (line == null)
{
return;
}
// Get Controller
GeometricNetworkControllerMembership controller = line.Parent;
// Suspend Rule Events
controller.Suspend();
// Get Start and End Elements
Element elementStart = line.Start.Shape;
Element elementEnd = line.End.Shape;
// Update GeometricNetwork Name Property
if (elementStart == null)
{
controller.GeometricNetworkName = string.Empty;
}
else if (elementStart is EsriShape <GeometricNetwork> )
{
EsriShape <GeometricNetwork> shape = (EsriShape <GeometricNetwork>)elementStart;
GeometricNetwork geometricNetwork = shape.Parent;
controller.GeometricNetworkName = geometricNetwork.Name;
}
//
DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default;
SchemaModel schemaModel = diagrammerEnvironment.SchemaModel;
ObjectClass objectClass = schemaModel.FindParent(controller);
if (objectClass != null)
{
objectClass.ControllerMemberships.Remove(controller);
}
if (elementEnd == null)
{
controller.AncillaryRoleFieldName = string.Empty;
controller.EnabledFieldName = string.Empty;
}
else if (elementEnd is EsriShape <FeatureClass> )
{
EsriShape <FeatureClass> es = (EsriShape <FeatureClass>)elementEnd;
FeatureClass featureClass = es.Parent;
featureClass.ControllerMemberships.Add(controller);
}
// Resume Controller Events
controller.Resume();
}
//
// CONSTRUCTOR
//
public EsriShape(T parent) : base()
{
this._parent = parent;
//
this.SuspendEvents = true;
// Get a stencil containing some basic shapes
BasicStencil stencil = (BasicStencil)Crainiate.ERM4.Component.Instance.GetStencil(typeof(BasicStencil));
this.BorderWidth = 2f;
this.Size = new Size(100, 40);
this.SmoothingMode = SmoothingMode.HighQuality;
this.StencilItem = stencil[BasicStencilType.RoundedRectangle];
this.Label = new TextLabel();
this.Label.Color = ModelSettings.Default.TextColor;
if (typeof(T) == typeof(DomainCodedValue))
{
DomainCodedValue domainCodedValue = this._parent as DomainCodedValue;
this.BorderColor = ColorSettings.Default.CodedValueDomainColor;
this.GradientColor = ColorSettings.Default.CodedValueDomainColor;
this.Label.Text = domainCodedValue.Name;
this.Tooltip = domainCodedValue.Name;
}
else if (typeof(T) == typeof(DomainRange))
{
DomainRange domainRange = this._parent as DomainRange;
this.BorderColor = ColorSettings.Default.RangeDomainColor;
this.GradientColor = ColorSettings.Default.RangeDomainColor;
this.Label.Text = domainRange.Name;
this.Tooltip = domainRange.Name;
}
else if (typeof(T) == typeof(FeatureClass))
{
FeatureClass featureClass = this._parent as FeatureClass;
this.BorderColor = ColorSettings.Default.FeatureClassColor;
this.GradientColor = ColorSettings.Default.FeatureClassColor;
this.Label.Text = featureClass.Name;
this.Tooltip = featureClass.Name;
}
else if (typeof(T) == typeof(ObjectClass))
{
ObjectClass objectClass = this._parent as ObjectClass;
this.BorderColor = ColorSettings.Default.ObjectClassColor;
this.GradientColor = ColorSettings.Default.ObjectClassColor;
this.Label.Text = objectClass.Name;
this.Tooltip = objectClass.Name;
}
else if (typeof(T) == typeof(RelationshipClass))
{
RelationshipClass relationship = this._parent as RelationshipClass;
this.BorderColor = ColorSettings.Default.RelationshipColor;
this.GradientColor = ColorSettings.Default.RelationshipColor;
this.Label.Text = relationship.Name;
this.Tooltip = relationship.Name;
}
else if (typeof(T) == typeof(Subtype))
{
Subtype subtype = this._parent as Subtype;
this.BorderColor = ColorSettings.Default.SubtypeColor;
this.GradientColor = ColorSettings.Default.SubtypeColor;
this.Label.Text = subtype.SubtypeName;
this.Tooltip = subtype.SubtypeName;
}
else if (typeof(T) == typeof(Field))
{
Field field = this._parent as Field;
this.BorderColor = ColorSettings.Default.FieldColor;
this.GradientColor = ColorSettings.Default.FieldColor;
this.Label.Text = field.Name;
this.Tooltip = field.Name;
}
else if (typeof(T) == typeof(SubtypeField))
{
SubtypeField subtypeField = this._parent as SubtypeField;
this.BorderColor = ColorSettings.Default.SubtypeFieldColor;
this.GradientColor = ColorSettings.Default.SubtypeFieldColor;
this.Label.Text = subtypeField.FieldName;
this.Tooltip = subtypeField.FieldName;
}
else if (typeof(T) == typeof(FeatureDataset))
{
FeatureDataset featureDataset = this._parent as FeatureDataset;
this.BorderColor = ColorSettings.Default.FeatureDatasetColor;
this.GradientColor = ColorSettings.Default.FeatureDatasetColor;
this.Label.Text = featureDataset.Name;
this.Tooltip = featureDataset.Name;
}
else if (typeof(T) == typeof(GeometricNetwork))
{
GeometricNetwork geometricNetwork = this._parent as GeometricNetwork;
this.BorderColor = ColorSettings.Default.GeometricNetworkColor;
this.GradientColor = ColorSettings.Default.GeometricNetworkColor;
this.Label.Text = geometricNetwork.Name;
this.Tooltip = geometricNetwork.Name;
}
else if (typeof(T) == typeof(Network))
{
Network network = this._parent as Network;
this.BorderColor = ColorSettings.Default.NetworkColor;
this.GradientColor = ColorSettings.Default.NetworkColor;
this.Label.Text = network.Name;
this.Tooltip = network.Name;
}
else if (typeof(T) == typeof(Topology))
{
Topology topology = this._parent as Topology;
this.BorderColor = ColorSettings.Default.TopologyColor;
this.GradientColor = ColorSettings.Default.TopologyColor;
this.Label.Text = topology.Name;
this.Tooltip = topology.Name;
}
else if (typeof(T) == typeof(Terrain))
{
Terrain terrain = this._parent as Terrain;
this.BorderColor = ColorSettings.Default.TerrainColor;
this.GradientColor = ColorSettings.Default.TerrainColor;
this.Label.Text = terrain.Name;
this.Tooltip = terrain.Name;
}
//
this.SuspendEvents = false;
}
public override void Errors(List <Error> list, EsriTable table)
{
// This controller must be assigned to a FeatureClass
FeatureClass featureClass = table as FeatureClass;
if (table.GetType() != typeof(FeatureClass))
{
list.Add(new ErrorObject(this, table, "A geometric network controller is ONLY supported in FeatureClasses", ErrorType.Error));
}
// GeometricNetwork Name
if (string.IsNullOrEmpty(this._geometricNetworkName))
{
list.Add(new ErrorObject(this, table, "The controller property 'GeometricNetworkName' can not be empty", ErrorType.Error));
}
else
{
GeometricNetwork geometricNetwork = DiagrammerEnvironment.Default.SchemaModel.FindGeometricNetwork(this._geometricNetworkName);
if (geometricNetwork == null)
{
string message = string.Format("The geometric network [{0}] referenced in the controller does not exist", this._geometricNetworkName);
list.Add(new ErrorObject(this, table, message, ErrorType.Error));
}
}
// Enabled Field Cannot be NULL/Empty
if (string.IsNullOrEmpty(this._enabledFieldName))
{
list.Add(new ErrorObject(this, table, "The controller property 'EnabledFieldName' can not be empty", ErrorType.Error));
}
else
{
if (featureClass != null)
{
Field field = featureClass.FindField(this._enabledFieldName);
if (field == null)
{
string message = string.Format("The geometric network controller cannot find 'enabled field' [{0}] in the featureclass [{1}]", this._enabledFieldName, featureClass.Name);
list.Add(new ErrorObject(this, table, message, ErrorType.Error));
}
else
{
if (field.FieldType != esriFieldType.esriFieldTypeSmallInteger)
{
string message = string.Format("The geometric network controller references an 'enabled field' [{0}] in the featureclass [{1}] that is not a 'Short Integer'", this._enabledFieldName, featureClass.Name);
list.Add(new ErrorObject(this, table, message, ErrorType.Error));
}
}
}
}
// Ancillary Role / Ancillary Role Field
switch (this._networkClassAncillaryRole)
{
case esriNetworkClassAncillaryRole.esriNCARNone:
if (!string.IsNullOrEmpty(this._ancillaryRoleFieldName))
{
string message = string.Format("The ancillary role field name should be empty if the role (in a geometric network controller) is set to none.");
list.Add(new ErrorObject(this, table, message, ErrorType.Error));
}
break;
case esriNetworkClassAncillaryRole.esriNCARSourceSink:
if (string.IsNullOrEmpty(this._ancillaryRoleFieldName))
{
string message = string.Format("The ancillary role field name can not be empty for this role in a geometric network controller");
list.Add(new ErrorObject(this, table, message, ErrorType.Error));
}
else
{
if (featureClass != null)
{
Field field = featureClass.FindField(this._ancillaryRoleFieldName);
if (field == null)
{
string message = string.Format("The geometric network controller cannot find 'ancillary role field' [{0}] in the featureclass [{1}]", this._ancillaryRoleFieldName, featureClass.Name);
list.Add(new ErrorObject(this, table, message, ErrorType.Error));
}
else
{
if (field.FieldType != esriFieldType.esriFieldTypeSmallInteger)
{
string message = string.Format("The geometric network controller references an 'ancillary role field' [{0}] in the featureclass [{1}] that is not a 'Short Integer'", this._ancillaryRoleFieldName, featureClass.Name);
list.Add(new ErrorObject(this, table, message, ErrorType.Error));
}
}
}
}
break;
}
}
public GeometricNetwork(GeometricNetwork prototype) : base(prototype) {
if (prototype.Extent != null) {
this._extent = prototype.Extent.Clone() as Extent;
}
if (prototype.SpatialReference != null) {
this._spatialReference = prototype.SpatialReference.Clone() as SpatialReference;
}
this._networkType = prototype.NetworkType;
this._orphanJunctionFeatureClassName = prototype.OrphanJunctionFeatureClassName;
// Add Cloned Rules
this._connectivityRules = new List<ConnectivityRule>();
foreach (ConnectivityRule connnectivityRule in prototype.ConnectivityRules) {
this._connectivityRules.Add((ConnectivityRule)connnectivityRule.Clone());
}
// Add Cloned Network Weights
this._netWeights = new List<NetWeight>();
foreach (NetWeight netWeight in prototype.NetworkWeights) {
this._netWeights.Add((NetWeight)netWeight.Clone());
}
// Add Cloned Network Weight Associations
this._netWeightAssociations = new List<NetWeightAssociation>();
foreach(NetWeightAssociation netWeightAssociation in prototype.NetworkWeightAssociations){
this._netWeightAssociations.Add((NetWeightAssociation)netWeightAssociation.Clone());
}
}
private TreeNode CreateCatalogNode(TreeNode node, EsriTable table)
{
if (table.GetType() == typeof(DomainCodedValue))
{
// Get Coded Value Domain
DomainCodedValue domainCodedValue = (DomainCodedValue)table;
// Add Coded Value Domain
TreeNodeTable treeNode = new TreeNodeTable(domainCodedValue);
treeNode.ImageKey = Catalog.CODED_VALUE_DOMAIN;
treeNode.SelectedImageKey = Catalog.CODED_VALUE_DOMAIN;
treeNode.Text = domainCodedValue.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(DomainRange))
{
// Get Range Domain
DomainRange domainRange = (DomainRange)table;
// Add Range Domain
TreeNodeTable treeNode = new TreeNodeTable(domainRange);
treeNode.ImageKey = Catalog.RANGE_DOMAIN;
treeNode.SelectedImageKey = Catalog.RANGE_DOMAIN;
treeNode.Text = domainRange.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(FeatureClass))
{
// Get FeatureClass
FeatureClass featureClass = (FeatureClass)table;
// Add FeatureClass Node
string imageKey = null;
switch (featureClass.FeatureType)
{
case ESRI.ArcGIS.Geodatabase.esriFeatureType.esriFTAnnotation:
imageKey = Catalog.ANNOTATION_FEATURE_CLASS;
break;
case ESRI.ArcGIS.Geodatabase.esriFeatureType.esriFTDimension:
imageKey = Catalog.DIMENSION_FEATURE_CLASS;
break;
case ESRI.ArcGIS.Geodatabase.esriFeatureType.esriFTSimple:
switch (featureClass.ShapeType)
{
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryMultipoint:
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint:
imageKey = Catalog.POINT_FEATURE_CLASS;
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon:
imageKey = Catalog.POLYGON_FEATURE_CLASS;
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline:
imageKey = Catalog.POLYLINE_FEATURE_CLASS;
break;
case ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryMultiPatch:
imageKey = Catalog.MULTIPATCH_FEATURE_CLASS;
break;
default:
imageKey = Catalog.POINT_FEATURE_CLASS;
break;
}
break;
default:
imageKey = POINT_FEATURE_CLASS;
break;
}
TreeNodeTable treeNode = new TreeNodeTable(featureClass);
treeNode.ImageKey = imageKey;
treeNode.SelectedImageKey = imageKey;
treeNode.Text = featureClass.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(FeatureDataset))
{
// Get FeatureDataset
FeatureDataset featureDataset = (FeatureDataset)table;
// Add FeatureDataset Node
TreeNodeTable treeNode = new TreeNodeTable(featureDataset);
treeNode.ImageKey = Catalog.FEATURE_DATASET;
treeNode.SelectedImageKey = Catalog.FEATURE_DATASET;
treeNode.Text = featureDataset.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(GeometricNetwork))
{
// Get GeometricNetwork
GeometricNetwork geometricNetwork = (GeometricNetwork)table;
// Add GeometricNetwork Node
TreeNodeTable treeNode = new TreeNodeTable(geometricNetwork);
treeNode.ImageKey = Catalog.GEOMETRIC_NETWORK;
treeNode.SelectedImageKey = Catalog.GEOMETRIC_NETWORK;
treeNode.Text = geometricNetwork.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(Network))
{
// Get Network
Network network = (Network)table;
// Add Network TreeNode
TreeNodeTable treeNode = new TreeNodeTable(network);
treeNode.ImageKey = Catalog.NETWORK_DATASET;
treeNode.SelectedImageKey = Catalog.NETWORK_DATASET;
treeNode.Text = network.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(ObjectClass))
{
// Get ObjectClass
ObjectClass objectClass = (ObjectClass)table;
// Add ObjectClass TreeNode
TreeNodeTable treeNode = new TreeNodeTable(objectClass);
treeNode.ImageKey = Catalog.TABLE;
treeNode.SelectedImageKey = Catalog.TABLE;
treeNode.Text = objectClass.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(RasterBand))
{
// Get RasterBand
RasterBand rasterBand = (RasterBand)table;
// Add RasterBand TreeNode
TreeNodeTable treeNode = new TreeNodeTable(rasterBand);
treeNode.ImageKey = Catalog.RASTER_BAND;
treeNode.SelectedImageKey = Catalog.RASTER_BAND;
treeNode.Text = rasterBand.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(RasterCatalog))
{
// Get RasterCatalog
RasterCatalog rasterCatalog = (RasterCatalog)table;
// Add RasterCatalog TreeNode
TreeNodeTable treeNode = new TreeNodeTable(rasterCatalog);
treeNode.ImageKey = Catalog.RASTER_CATALOG;
treeNode.SelectedImageKey = Catalog.RASTER_CATALOG;
treeNode.Text = rasterCatalog.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(RasterDataset))
{
// Get RasterDataset
RasterDataset rasterDataset = (RasterDataset)table;
// Add RasterDataset TreeNode
TreeNodeTable treeNode = new TreeNodeTable(rasterDataset);
treeNode.ImageKey = Catalog.RASTER_DATASET;
treeNode.SelectedImageKey = Catalog.RASTER_DATASET;
treeNode.Text = rasterDataset.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(RelationshipClass))
{
// Get RelationshipClass
RelationshipClass relationshipClass = (RelationshipClass)table;
// Add RelationshipClass TreeNode
TreeNodeTable treeNode = new TreeNodeTable(relationshipClass);
treeNode.ImageKey = Catalog.RELATIONSHIP_CLASS;
treeNode.SelectedImageKey = Catalog.RELATIONSHIP_CLASS;
treeNode.Text = relationshipClass.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(Subtype))
{
// Get Subtype
Subtype subtype = (Subtype)table;
// Add Subtype TreeNode
TreeNodeTable treeNode = new TreeNodeTable(subtype);
treeNode.ImageKey = Catalog.SUBTYPE;
treeNode.SelectedImageKey = Catalog.SUBTYPE;
treeNode.Text = subtype.SubtypeName;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(Terrain))
{
// Get Terrain
Terrain terrain = (Terrain)table;
// Add Terrain TreeNode
TreeNodeTable treeNode = new TreeNodeTable(terrain);
treeNode.ImageKey = Catalog.TERRAIN;
treeNode.SelectedImageKey = Catalog.TERRAIN;
treeNode.Text = terrain.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
if (table.GetType() == typeof(Topology))
{
// Get Topology
Topology topology = (Topology)table;
// Add Topology TreeNode
TreeNodeTable treeNode = new TreeNodeTable(topology);
treeNode.ImageKey = Catalog.TOPOLOGY;
treeNode.SelectedImageKey = Catalog.TOPOLOGY;
treeNode.Text = topology.Name;
node.Nodes.Add(treeNode);
return(treeNode);
}
return(null);
}
