public static Domain CreateDomain(Type type) { Domain domain = null; // Load XML Workspace Document Text if (type == typeof(DomainCodedValue)) { XPathNodeIterator iterator = Factory.LoadXml(Resources.FILE_DOMAIN_CODEDVALUE, "WorkspaceDefinition/Domains/Domain"); if (iterator.MoveNext()) { domain = new DomainCodedValue(iterator.Current); } } else if (type == typeof(DomainRange)) { XPathNodeIterator iterator = Factory.LoadXml(Resources.FILE_DOMAIN_RANGE, "WorkspaceDefinition/Domains/Domain"); if (iterator.MoveNext()) { domain = new DomainRange(iterator.Current); } } return domain; }
public static Domain CreateDomain(Type type) { Domain domain = null; // Load XML Workspace Document Text if (type == typeof(DomainCodedValue)) { XPathNodeIterator iterator = Factory.LoadXml(Resources.FILE_DOMAIN_CODEDVALUE, "WorkspaceDefinition/Domains/Domain"); if (iterator.MoveNext()) { domain = new DomainCodedValue(iterator.Current); } } else if (type == typeof(DomainRange)) { XPathNodeIterator iterator = Factory.LoadXml(Resources.FILE_DOMAIN_RANGE, "WorkspaceDefinition/Domains/Domain"); if (iterator.MoveNext()) { domain = new DomainRange(iterator.Current); } } return(domain); }
public DomainCodedValue(DomainCodedValue prototype) : base(prototype) { }
// // 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; }
public override void Errors(List <Error> list) { // Field Name Null or Empty if (string.IsNullOrEmpty(this._fieldName)) { list.Add(new ErrorTableRow(this, "Subtype Field names cannot be empty", ErrorType.Error)); } // Get DiagrammerEnvironment Singleton DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default; SchemaModel schemaModel = diagrammerEnvironment.SchemaModel; // Get Subtype Subtype subtype = (Subtype)this.Table; // Get ObjectClass ObjectClass objectClass = subtype.GetParent(); if (objectClass == null) { // This error is handled by the Subtype class return; } // Get Field Field field = objectClass.FindField(this._fieldName); if (field == null) { // Field is missing in parent ObjectClass string message = string.Format("The subtype field [{0}] does not exist in the parent objectclass", this._fieldName); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); return; } // Warning if parent default value and domain are identical if (this._defaultValue == field.DefaultValue && this._domainName == field.Domain) { string message = string.Format("The default values and domain for the subtype field [{0}] are identical to those in the parent objectclass", this._fieldName); list.Add(new ErrorTableRow(this, message, ErrorType.Warning)); } // Field can only be small int, long in, single, double, text, date, guid switch (field.FieldType) { case esriFieldType.esriFieldTypeDate: case esriFieldType.esriFieldTypeDouble: case esriFieldType.esriFieldTypeGUID: case esriFieldType.esriFieldTypeInteger: case esriFieldType.esriFieldTypeSingle: case esriFieldType.esriFieldTypeSmallInteger: case esriFieldType.esriFieldTypeString: // OK break; case esriFieldType.esriFieldTypeRaster: case esriFieldType.esriFieldTypeBlob: case esriFieldType.esriFieldTypeGeometry: case esriFieldType.esriFieldTypeOID: case esriFieldType.esriFieldTypeGlobalID: case esriFieldType.esriFieldTypeXML: string message = string.Format("The subtype field [{0}] must use a field of type Date, Double, Guid, Integer, Single, SmallInteger or String", this._fieldName); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); break; } // Find Domain if (!string.IsNullOrEmpty(this._domainName)) { // Get Domain Domain domain = schemaModel.FindDomain(this._domainName); if (domain == null) { // Domain does not exit string message = string.Format("The domain [{0}] for field [{1}] does not exist", this._domainName, field.Name); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } else { // Compare domain and field types if (field.FieldType != domain.FieldType) { string message = string.Format("The field [{0}] and assigned domain [{1}] do not have matching field types.", field.Name, this._domainName); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } // Check Default Value ( if (!string.IsNullOrEmpty(this._defaultValue)) { string message = null; if (!domain.IsValid(this._defaultValue, out message)) { list.Add(new ErrorTableRow(this, message, ErrorType.Warning)); } } // Check if a domain value is too long for the text field if (field.FieldType == esriFieldType.esriFieldTypeString && domain.FieldType == esriFieldType.esriFieldTypeString && domain.GetType() == typeof(DomainCodedValue)) { DomainCodedValue domain2 = (DomainCodedValue)domain; foreach (DomainCodedValueRow x in domain2.CodedValues) { if (string.IsNullOrEmpty(x.Code)) { continue; } if (x.Code.Length > field.Length) { string message = string.Format("The domain [{0}] has a value [{1}] that is too long for the field [{2}]", this._domainName, x, this._fieldName); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } } } } } // Check validity of default value against field type if (!string.IsNullOrEmpty(this._defaultValue)) { string message; if (!GeodatabaseUtility.IsValidateValue(field.FieldType, this._defaultValue, out message)) { string message2 = string.Format("Default value [{0}] {1}", this._defaultValue, message); list.Add(new ErrorTableRow(this, message2, ErrorType.Error)); } } // if (!string.IsNullOrEmpty(this._defaultValue)) { if (!string.IsNullOrEmpty(this._domainName)) { if (!string.IsNullOrEmpty(field.Domain)) { if (this._domainName != field.Domain) { Domain domain2 = schemaModel.FindDomain(field.Domain); string message = null; if (!domain2.IsValid(this._defaultValue, out message)) { string message2 = string.Format("NIM013605: Field [{0}] - {1}", this._fieldName, message); list.Add(new ErrorTableRow(this, message2, ErrorType.Error)); } } } } } }
// // 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; }
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); }
public override void Errors(List <Error> list) { // Get Parent ObjectClass ObjectClass objectClass = (ObjectClass)this.Table; // Get ObjectClass Fields List <Field> fields = objectClass.GetFields(); // Get Schema Model SchemaModel model = (SchemaModel)objectClass.Container; // Add GeometryDef Errors if (this._geometryDef != null) { this._geometryDef.Errors(list, (EsriTable)this.Table); } // GeometryDef only valid for Geometry Fields switch (this._fieldType) { case esriFieldType.esriFieldTypeGeometry: if (this._geometryDef == null) { list.Add(new ErrorTableRow(this, "Geometry Fields Must have a GeometryDef defined.", ErrorType.Error)); } break; case esriFieldType.esriFieldTypeBlob: case esriFieldType.esriFieldTypeDate: case esriFieldType.esriFieldTypeDouble: case esriFieldType.esriFieldTypeGlobalID: case esriFieldType.esriFieldTypeGUID: case esriFieldType.esriFieldTypeInteger: case esriFieldType.esriFieldTypeOID: case esriFieldType.esriFieldTypeRaster: case esriFieldType.esriFieldTypeSingle: case esriFieldType.esriFieldTypeSmallInteger: case esriFieldType.esriFieldTypeString: case esriFieldType.esriFieldTypeXML: if (this._geometryDef != null) { list.Add(new ErrorTableRow(this, "Only Geometry Fields can have a GeometryDef defined.", ErrorType.Error)); } break; } // Raster Fields can have a RasterDef switch (this._fieldType) { case esriFieldType.esriFieldTypeRaster: if (this._rasterDef == null) { string message = string.Format("The raster field [{0}] does not have a RasterDef assigned", this._name); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } break; case esriFieldType.esriFieldTypeBlob: case esriFieldType.esriFieldTypeDate: case esriFieldType.esriFieldTypeDouble: case esriFieldType.esriFieldTypeGeometry: case esriFieldType.esriFieldTypeGUID: case esriFieldType.esriFieldTypeInteger: case esriFieldType.esriFieldTypeOID: case esriFieldType.esriFieldTypeSingle: case esriFieldType.esriFieldTypeSmallInteger: case esriFieldType.esriFieldTypeString: case esriFieldType.esriFieldTypeGlobalID: case esriFieldType.esriFieldTypeXML: if (this._rasterDef != null) { string message = string.Format("The field [{0}] is invalid. Only raster fields can have a RasterDef", this._name); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } break; } // Field Name Null or Empty if (string.IsNullOrEmpty(this._name)) { list.Add(new ErrorTableRow(this, "Field names cannot be empty", ErrorType.Error)); } // Validate Field Name if (!string.IsNullOrEmpty(this._name)) { // Get Validator Validator validator = WorkspaceValidator.Default.Validator; string message = null; if (!validator.ValidateFieldName(this._name, out message)) { string message2 = string.Format("Field [{0}] {1}", this._name, message); list.Add(new ErrorTableRow(this, message2, ErrorType.Error)); } } // Alias name more than 255 characters long if (!string.IsNullOrEmpty(this._aliasName)) { if (this._aliasName.Length > 255) { string message = string.Format("Field [{0}]. Alias name cannot be longer than 255 characters", this._name); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } } // Find Domain Domain domain = null; if (!string.IsNullOrEmpty(this._domain)) { domain = model.FindDomain(this._domain); if (domain == null) { // Domain does not exit string message = string.Format("The domain [{0}] for field [{1}] does not exist", this._domain, this._name); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } else { // Compare domain and field types if (this._fieldType != domain.FieldType) { string message = string.Format("The field [{0}] and assigned domain [{1}] do not have matching field types", this._name, this._domain); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } // Check Default Value if (!string.IsNullOrEmpty(this._defaultValue)) { string message = null; if (!domain.IsValid(this._defaultValue, out message)) { list.Add(new ErrorTableRow(this, message, ErrorType.Warning)); } } // Check if a domain value is too long for the text field if (this._fieldType == esriFieldType.esriFieldTypeString && domain.FieldType == esriFieldType.esriFieldTypeString && domain.GetType() == typeof(DomainCodedValue)) { DomainCodedValue domain2 = (DomainCodedValue)domain; foreach (DomainCodedValueRow x in domain2.CodedValues) { if (string.IsNullOrEmpty(x.Code)) { continue; } if (x.Code.Length > this._length) { string message = string.Format("The domain [{0}] has a value [{1}] that is too long for the field [{2}]", this._domain, x, this._name); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } } } } } // Check validity of default value against field type if (!string.IsNullOrEmpty(this._defaultValue)) { string message; if (!GeodatabaseUtility.IsValidateValue(this._fieldType, this._defaultValue, out message)) { string message2 = string.Format("Default value '{0}' {1}", this._defaultValue, message); list.Add(new ErrorTableRow(this, message2, ErrorType.Error)); } } // Check for unsupported field types switch (this._fieldType) { case esriFieldType.esriFieldTypeBlob: case esriFieldType.esriFieldTypeDate: case esriFieldType.esriFieldTypeDouble: case esriFieldType.esriFieldTypeGeometry: case esriFieldType.esriFieldTypeGUID: case esriFieldType.esriFieldTypeInteger: case esriFieldType.esriFieldTypeOID: case esriFieldType.esriFieldTypeRaster: case esriFieldType.esriFieldTypeSingle: case esriFieldType.esriFieldTypeSmallInteger: case esriFieldType.esriFieldTypeString: case esriFieldType.esriFieldTypeGlobalID: break; case esriFieldType.esriFieldTypeXML: string message = string.Format("Field type '{0}' is unsupported", this._fieldType.ToString()); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); break; } // Length must be > 0 if (this._length < 0) { list.Add(new ErrorTableRow(this, "Field length cannot be less than zero", ErrorType.Error)); } // ModelName cannot be longer than 255 characters if (!(string.IsNullOrEmpty(this._modelName))) { if (this._modelName.Length > 255) { list.Add(new ErrorTableRow(this, "Model name cannot be greater than 255 characters long", ErrorType.Error)); } } // Precision must be > 0 if (this._precision < 0) { list.Add(new ErrorTableRow(this, "Field precision cannot be less than zero", ErrorType.Error)); } // Scale must be > 0 if (this._scale < 0) { list.Add(new ErrorTableRow(this, "Field scake cannot be less than zero", ErrorType.Error)); } // IsNullable if (this._isNullable) { switch (this._fieldType) { case esriFieldType.esriFieldTypeBlob: case esriFieldType.esriFieldTypeDate: case esriFieldType.esriFieldTypeDouble: case esriFieldType.esriFieldTypeGeometry: case esriFieldType.esriFieldTypeGUID: case esriFieldType.esriFieldTypeInteger: case esriFieldType.esriFieldTypeRaster: case esriFieldType.esriFieldTypeSingle: case esriFieldType.esriFieldTypeSmallInteger: case esriFieldType.esriFieldTypeString: case esriFieldType.esriFieldTypeXML: break; case esriFieldType.esriFieldTypeGlobalID: case esriFieldType.esriFieldTypeOID: string message = string.Format("Field type '{0}' cannot have IsNullable = True", this._fieldType.ToString()); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); break; } } }
public override void Errors(List <Error> list) { // Get Table DomainCodedValue domain = (DomainCodedValue)this.Table; // Check if Name is null or empty if (string.IsNullOrEmpty(this._name)) { list.Add(new ErrorTableRow(this, "Name cannot be empty", ErrorType.Error)); } // Check if Code can be converted to target type if (!string.IsNullOrEmpty(this._code)) { switch (domain.FieldType) { case esriFieldType.esriFieldTypeSmallInteger: short value1; bool valid1 = short.TryParse(this._code, out value1); if (!valid1) { string message = string.Format("Code '{0}' is not a valid short", this._code); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } break; case esriFieldType.esriFieldTypeInteger: int value2; bool valid2 = int.TryParse(this._code, out value2); if (!valid2) { string message = string.Format("Code '{0}' is not a valid int", this._code); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } break; case esriFieldType.esriFieldTypeSingle: float value3; bool valid3 = float.TryParse(this._code, out value3); if (!valid3) { string message = string.Format("Code '{0}' is not a valid float", this._code); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } break; case esriFieldType.esriFieldTypeDouble: double value4; bool valid4 = double.TryParse(this._code, out value4); if (!valid4) { string message = string.Format("Code '{0}' is not a valid double", this._code); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } break; case esriFieldType.esriFieldTypeString: break; case esriFieldType.esriFieldTypeDate: CultureInfo cultureInfo = CultureInfo.CurrentCulture; DateTimeFormatInfo dateTimeFormatInfo = cultureInfo.DateTimeFormat; DateTime value5; bool valid5 = DateTime.TryParseExact(this._code, dateTimeFormatInfo.SortableDateTimePattern, cultureInfo, DateTimeStyles.None, out value5); if (!valid5) { string message = string.Format("Code '{0}' is not a valid date", this._code); list.Add(new ErrorTableRow(this, message, ErrorType.Error)); } break; } } }