Exemplo n.º 1
0
        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;
        }
Exemplo n.º 4
0
        //
        // 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();
        }
Exemplo n.º 6
0
        //
        // 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());
            }
        }
Exemplo n.º 9
0
        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);
        }