private void MenuItem_Activate(object sender, EventArgs e) { try { TreeNode treeNode = this.treeView1.SelectedNode; if (treeNode == null) { return; } TreeNodeTable treeNodeTable = treeNode as TreeNodeTable; if (treeNodeTable == null) { return; } EsriTable table = treeNodeTable.Table; if (table == null) { return; } if (sender == this.menuButtonItemScroll) { this._model.ScrollToElement(table); } else if (sender == this.menuButtonItemFlash) { table.Flash(); } } catch (Exception ex) { ExceptionDialog.HandleException(ex); } }
private void TreeView_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e) { try { // Get Double Clicked Node (and Table) if (e == null) { return; } TreeNode treeNode = e.Node; if (treeNode == null) { return; } TreeNodeTable treeNodeTable = treeNode as TreeNodeTable; if (treeNodeTable == null) { return; } EsriTable table = treeNodeTable.Table; if (table == null) { return; } // Scroll to Table this._model.ScrollToElement(table); } catch (Exception ex) { ExceptionDialog.HandleException(ex); } }
private void TreeView_AfterSelect(object sender, TreeViewEventArgs e) { try { if (e.Node is TreeNodeGeodatabase) { TreeNodeGeodatabase treeNodeGeodatabase = (TreeNodeGeodatabase)e.Node; EsriModel model = treeNodeGeodatabase.Model; model.SelectElements(false); } else if (e.Node is TreeNodeTable) { TreeNodeTable treeNodeTable = (TreeNodeTable)e.Node; EsriTable table = treeNodeTable.Table; EsriModel model = (EsriModel)table.Container; model.SelectElements(false); table.Selected = true; } else if (e.Node is TreeNodeGroup) { } } catch (Exception ex) { ExceptionDialog.HandleException(ex); } }
public override void Errors(List <Error> list, EsriTable table) { // Check if class/subtype exists EsriTable table2 = DiagrammerEnvironment.Default.SchemaModel.FindObjectClassOrSubtype(this._classID, this._subtypeCode); if (table2 == null) { string message = string.Format("The junction subtype [{0}::{1}] does not exist", this._classID.ToString(), this._subtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } }
public void Validate2(EsriTable table) { // Clear Errors this.m_errors.Clear(); // Get Errors table.Errors(this.m_errors); // Refresh Error List this.RefreshErrorList(); }
public override void Errors(List <Error> list, EsriTable table) { // TODO Add RasterDef Errors // Add Spatial Reference Errors if (this._spatialReference == null) { list.Add(new ErrorObject(this, table, "SpatialReference cannot be null", ErrorType.Error)); } else { this._spatialReference.Errors(list, table); } }
public override void Errors(List <Error> list, EsriTable table) { // Write Base Errors base.Errors(list, table); // TODO: If One-One then Origin Cardinality must be 0 or 1 // TODO: If One-One then Origin Cardinality must be 0 or 1 // TODO: If One-Many then Origin Cardinality must be 0 or 1 // TODO: If One-Many then Origin Cardinality must be 0..M // TODO: If Many-Many then Origin Cardinality must be 0..M // TODO: If Many-Many then Origin Cardinality must be 0..M // TODO: Origin Cardinality. Min <= Max // TODO: Destination Cardinality. Min <= Max // TODO: Origin Cardinality. OK if Min and Max both -1. (Default Cardinatity) // TODO: Origin Destination. OK if Min and Max both -1. (Default Cardinatity) }
public override void Errors(List <Error> list, EsriTable table) { // Key cannot be empty if (string.IsNullOrEmpty(this._key)) { list.Add(new ErrorObject(this, table, "Property Key cannot be empty", ErrorType.Error)); } // Type cannot be empty if (string.IsNullOrEmpty(this._type)) { list.Add(new ErrorObject(this, table, "Property Type cannot be empty", ErrorType.Error)); } // [Warning] if (string.IsNullOrEmpty(this._value)) { list.Add(new ErrorObject(this, table, "Property Value is empty", ErrorType.Warning)); } }
private void TreeView_KeyDown(object sender, KeyEventArgs e) { try { switch (e.KeyData) { case Keys.Enter: // Handle Event e.Handled = true; // Get Table TreeNode treeNode = this.treeView1.SelectedNode; if (treeNode == null) { return; } TreeNodeTable treeNodeTable = treeNode as TreeNodeTable; if (treeNodeTable == null) { return; } EsriTable table = treeNodeTable.Table; if (table == null) { return; } // Scroll to Table this._model.ScrollToElement(table); break; default: break; } } catch (Exception ex) { ExceptionDialog.HandleException(ex); } }
public override void Errors(List <Error> list, EsriTable table) { // Add Spatial Reference Errors if (this._spatialReference == null) { list.Add(new ErrorObject(this, table, "SpatialReference cannot be null", ErrorType.Error)); } else { this._spatialReference.Errors(list, table); } // XMin > XMax if (this._xMin > this._xMax) { list.Add(new ErrorObject(this, table, "XMin is larger thatn XMax", ErrorType.Error)); } // YMin < YMax if (this._yMin > this._yMax) { list.Add(new ErrorObject(this, table, "YMin is larger thatn YMax", ErrorType.Error)); } }
private TreeNode FindNode(TreeNode treeNode, EsriTable table) { // if (treeNode is TreeNodeTable) { TreeNodeTable treeNodeTable = (TreeNodeTable)treeNode; if (treeNodeTable.Table == table) { return(treeNodeTable); } } // foreach (TreeNode treeNodeChild in treeNode.Nodes) { TreeNode treeNode2 = this.FindNode(treeNodeChild, table); if (treeNode2 != null) { return(treeNode2); } } return(null); }
public override void Errors(List<Error> list, EsriTable table) { // TODO Street Name Fields Errors }
public override void Errors(List<Error> list, EsriTable table) { // TODO Evaluated Network Attribute Errors }
public override void Errors(List <Error> list, EsriTable table) { // Export SpatialReference Errors if (this._spatialReference != null) { this._spatialReference.Errors(list, table); } // AvgNumPoints if (this._avgNumPoints < 0) { // Must be positive list.Add(new ErrorObject(this, table, "AvgNumPoints must be positive", ErrorType.Error)); } // Check GridSize Configuration if (this._gridSize0 == -1 && this._gridSize1 == -1 && this._gridSize2 == -1) { // OK } else if (this._gridSize0 != -1 && this._gridSize1 == -1 && this._gridSize2 == -1) { // OK } else if (this._gridSize0 != -1 && this._gridSize1 != -1 && this._gridSize2 == -1) { // OK if (this._gridSize0 > this._gridSize1) { list.Add(new ErrorObject(this, table, "GridSize0 cannot be larger than GridSize1", ErrorType.Error)); } } else if (this._gridSize0 != -1 && this._gridSize1 != -1 && this._gridSize2 != -1) { // OK if (this._gridSize0 > this._gridSize1) { list.Add(new ErrorObject(this, table, "GridSize0 cannot be larger than GridSize1", ErrorType.Error)); } if (this._gridSize1 > this._gridSize2) { list.Add(new ErrorObject(this, table, "GridSize1 cannot be larger than GridSize2", ErrorType.Error)); } } else { // Invalid Combination string message = string.Format( "Grid configuration '{0}'/'{1}'/'{2}' is invalid", this._gridSize0.ToString(), this._gridSize1.ToString(), this._gridSize2.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // GridSize0 if (this._gridSize0 != -1) { if (this._gridSize0 < 0) { // Must be greater than zero list.Add(new ErrorObject(this, table, "GridSize0 must be greater than (or equal to) zero", ErrorType.Error)); } } // GridSize1 if (this._gridSize1 != -1) { if (this._gridSize1 < 0) { // Must be positive list.Add(new ErrorObject(this, table, "GridSize1 must be zero or a positive", ErrorType.Error)); } } // GridSize2 if (this._gridSize2 != -1) { if (this._gridSize2 < 0) { // Must be positive list.Add(new ErrorObject(this, table, "GridSize2 must be zero or a positive", ErrorType.Error)); } } }
public override void Errors(List<Error> list, EsriTable table) { // Write Base Errors base.Errors(list, table); // From Class ID and SubtypeCode EsriTable table2 = DiagrammerEnvironment.Default.SchemaModel.FindObjectClassOrSubtype(this._fromClassID, this._fromEdgeSubtypeCode); if (table2 == null) { string message = string.Format("Edge Connectivity Rule [{0}]: Can not identify the from edge [{1}::{0}]", this.RuleId.ToString(), this._fromClassID.ToString(), this._fromEdgeSubtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // To Class ID and SubtypeCode EsriTable table3 = DiagrammerEnvironment.Default.SchemaModel.FindObjectClassOrSubtype(this._toClassID, this._toEdgeSubtypeCode); if (table3 == null) { string message = string.Format("Edge Connectivity Rule [{0}]: Can not identify the to edge [{1}::{0}]", this.RuleId.ToString(), this._toClassID.ToString(), this._toEdgeSubtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // Default Class ID and SubtypeCode EsriTable table4 = DiagrammerEnvironment.Default.SchemaModel.FindObjectClassOrSubtype(this._defaultJunctionID, this._defaultJunctionSubtypeCode); if (table4 == null) { string message = string.Format("Edge Connectivity Rule [{0}]: Can not identify the default junction [{1}::{0}]", this.RuleId.ToString(), this._defaultJunctionID.ToString(), this._defaultJunctionSubtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } else { bool found = false; foreach (JunctionSubtype junctionSubtype in this._junctionSubtypes) { if (junctionSubtype.ClassID == this._defaultJunctionID && junctionSubtype.SubtypeCode == this._defaultJunctionSubtypeCode) { found = true; break; } } if (!found) { string message = string.Format("Edge Connectivity Rule [{0}]: The default junction [{1}::{0}] in not contained in the junction list", this.RuleId.ToString(), this._defaultJunctionID.ToString(), this._defaultJunctionSubtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } } // Junction Subtype if (this._junctionSubtypes.Count == 0) { string message = string.Format("Edge Connectivity Rule [{0}]: The rule must at least one junction defined", this.RuleId.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } foreach (JunctionSubtype junctionSubtype in this._junctionSubtypes) { junctionSubtype.Errors(list, table); } }
public override void Errors(List<Error> list, EsriTable table) { // Write Base Errors base.Errors(list, table); // TODO: If One-One then Origin Cardinality must be 0 or 1 // TODO: If One-One then Origin Cardinality must be 0 or 1 // TODO: If One-Many then Origin Cardinality must be 0 or 1 // TODO: If One-Many then Origin Cardinality must be 0..M // TODO: If Many-Many then Origin Cardinality must be 0..M // TODO: If Many-Many then Origin Cardinality must be 0..M // TODO: Origin Cardinality. Min <= Max // TODO: Destination Cardinality. Min <= Max // TODO: Origin Cardinality. OK if Min and Max both -1. (Default Cardinatity) // TODO: Origin Destination. OK if Min and Max both -1. (Default Cardinatity) }
private void CreateTabbedDocument(EsriTable table, Type modelType) { TabbedDocument tabbedDocument = null; if (modelType == typeof(DomainModel)) { Domain domain = (Domain)table; tabbedDocument = new TabbedDocumentDomain(domain); } else if (modelType == typeof(GeometricNetworkModel)) { GeometricNetwork geometricNetwork = (GeometricNetwork)table; tabbedDocument = new TabbedDocumentGeometricNetwork(geometricNetwork); } else if (modelType == typeof(GeometricNetworkModelEE)) { GeometricNetwork geometricNetwork = (GeometricNetwork)table; tabbedDocument = new TabbedDocumentGeometricNetworkEE(geometricNetwork); } else if (modelType == typeof(GeometricNetworkModelEJ)) { GeometricNetwork geometricNetwork = (GeometricNetwork)table; tabbedDocument = new TabbedDocumentGeometricNetworkEJ(geometricNetwork); } else if (modelType == typeof(RelationshipModel)) { RelationshipClass relationshipClass = (RelationshipClass)table; tabbedDocument = new TabbedDocumentRelationship(relationshipClass); } else if (modelType == typeof(TopologyModel)) { Topology topology = (Topology)table; tabbedDocument = new TabbedDocumentTopology(topology); } else if (modelType == typeof(TopologyRuleModel)) { Topology topology = (Topology)table; tabbedDocument = new TabbedDocumentTopologyRule(topology); } else if (modelType == typeof(TerrainModel)) { Terrain terrain = (Terrain)table; tabbedDocument = new TabbedDocumentTerrain(terrain); } if (tabbedDocument == null) { return; } // Add Tabbed Document this.AddTabbedDocument(tabbedDocument); }
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); }
// // CONSTRUCTOR // public TreeNodeTable(EsriTable table) : base() { this.m_table = table; }
// // CONSTRUCTOR // public TreeNodeTable(EsriTable table) : base() { this.m_table = table; }
public ErrorTable(EsriTable table, string description, ErrorType errorType) : base(description, errorType) { this.m_table = table; }
public override void Errors(List<Error> list, EsriTable table) { // Write Base Errors base.Errors(list, table); }
public void Validate2(EsriTable table) { // Clear Errors this.m_errors.Clear(); // Get Errors table.Errors(this.m_errors); // Refresh Error List this.RefreshErrorList(); }
public override void Errors(List<Error> list, EsriTable table) { // TODO Add Errors }
public override void Errors(List<Error> list, EsriTable table) { // TODO Turn Feature Source Errors }
private TreeNode FindNode(TreeNode treeNode, EsriTable table) { // if (treeNode is TreeNodeTable) { TreeNodeTable treeNodeTable = (TreeNodeTable)treeNode; if (treeNodeTable.Table == table) { return treeNodeTable; } } // foreach (TreeNode treeNodeChild in treeNode.Nodes) { TreeNode treeNode2 = this.FindNode(treeNodeChild, table); if (treeNode2 != null) { return treeNode2; } } return null; }
public override void Errors(List <Error> list, EsriTable table) { // TODO Edge Feature Source Errors }
private void LoadModel() { // Store Selected EsriTable (if any) EsriTable table = null; if (this.treeView1.SelectedNode != null) { TreeNodeTable treeNodeTable = this.treeView1.SelectedNode as TreeNodeTable; if (treeNodeTable != null) { if (treeNodeTable.Table != null) { table = treeNodeTable.Table; } } } // Clear TreeView this.treeView1.Nodes.Clear(); // Exit if No Model if (this._model == null) { return; } // Get Datasets List <Dataset> datasets = this._model.GetDatasets(); // Get Domains List <Domain> domains = this._model.GetDomains(); // Start TreeView Update this.treeView1.BeginUpdate(); this.treeView1.Sorted = false; // Add Geodatabase Node TreeNodeGeodatabase treeNode = new TreeNodeGeodatabase(this._model); treeNode.ImageKey = Catalog.GEODATABASE; treeNode.SelectedImageKey = Catalog.GEODATABASE; treeNode.Text = this._model.Title; this.treeView1.Nodes.Add(treeNode); if (this.buttonItemCatalog.Checked) { // Sort Datasets datasets.Sort(); // Loop Throught Datasets foreach (Dataset dataset in datasets) { if (dataset is FeatureDataset) { // Get FeatureDataset FeatureDataset featureDataset = (FeatureDataset)dataset; // Add FeatureDataset Node TreeNode treeNode2 = this.CreateCatalogNode(treeNode, featureDataset); // Get Child Datasets List <Dataset> datasets2 = featureDataset.GetChildren(); datasets2.Sort(); foreach (Dataset dataset2 in datasets2) { TreeNode treeNode3 = this.CreateCatalogNode(treeNode2, dataset2); // Add Subtypes if ObjectClass if (dataset2 is ObjectClass) { // Get ObjectClass ObjectClass objectClass = (ObjectClass)dataset2; // Get Subtypes List <Subtype> subtypes = objectClass.GetSubtypes(); subtypes.Sort(); // Add Subtypes Nodes foreach (Subtype subtype in subtypes) { TreeNode treeNodeSubtype = this.CreateCatalogNode(treeNode3, subtype); } } } } } // Add Everything Else foreach (Dataset dataset in datasets) { // Skip FeatureDataset and FeatureDataset Objects if (dataset is FeatureDataset || dataset is GeometricNetwork || dataset is Network || dataset is RasterBand || dataset is Terrain || dataset is Topology) { continue; } // Skip Objects that Belong to a FeatureDataset if (dataset is FeatureClass || dataset is RelationshipClass) { Dataset parent = dataset.GetParent(); if (parent != null) { continue; } } // Create Node TreeNode treeNode2 = this.CreateCatalogNode(treeNode, dataset); // Add Subtypes if ObjectClass if (dataset is ObjectClass) { // Get ObjectClass ObjectClass objectClass = (ObjectClass)dataset; // Get Subtypes List <Subtype> subtypes = objectClass.GetSubtypes(); subtypes.Sort(); // Add Subtypes Nodes foreach (Subtype subtype in subtypes) { TreeNode treeNodeSubtype = this.CreateCatalogNode(treeNode2, subtype); } } // Add Raster Bands if (dataset.GetType() == typeof(RasterDataset)) { // Get RasterDataset RasterDataset rasterDataset = (RasterDataset)dataset; // Get RasterBands List <Dataset> rasterBands = rasterDataset.GetChildren(); // Add RasterBands foreach (Dataset datasetRasterBand in rasterBands) { if (datasetRasterBand.GetType() == typeof(RasterBand)) { RasterBand rasterBand = (RasterBand)datasetRasterBand; TreeNode treeNodeRasterBand = this.CreateCatalogNode(treeNode2, rasterBand); } } } } // Sort Domains domains.Sort(); // Add Domains foreach (Domain domain in domains) { TreeNode treeNodeDomain = this.CreateCatalogNode(treeNode, domain); } // Expand Geodatabase Node treeNode.Expand(); } else if (this.buttonItemCategorized.Checked) { // Loop for each Dataset foreach (Dataset dataset in datasets) { // Get Group Node Name string key = string.Empty; if (dataset.GetType() == typeof(FeatureDataset)) { key = Resources.TEXT_FEATURE_DATASET; } else if (dataset.GetType() == typeof(FeatureClass)) { key = Resources.TEXT_FEATURE_CLASS; } else if (dataset.GetType() == typeof(GeometricNetwork)) { key = Resources.TEXT_GEOMETRIC_NETWORK; } else if (dataset.GetType() == typeof(ObjectClass)) { key = Resources.TEXT_TABLE; } else if (dataset.GetType() == typeof(RasterBand)) { key = Resources.TEXT_RASTER_BAND; } else if (dataset.GetType() == typeof(RasterCatalog)) { key = Resources.TEXT_RASTER_CATALOG; } else if (dataset.GetType() == typeof(RasterDataset)) { key = Resources.TEXT_RASTER_DATASET; } else if (dataset.GetType() == typeof(RelationshipClass)) { key = Resources.TEXT_RELATIONSHIP; } else if (dataset.GetType() == typeof(Terrain)) { key = Resources.TEXT_TERRAIN; } else if (dataset.GetType() == typeof(Topology)) { key = Resources.TEXT_TOPOLOGY; } if (string.IsNullOrEmpty(key)) { continue; } // Get Group Node (create if it does not exist) TreeNodeGroup treeNodeGroup = null; foreach (TreeNodeGroup group in treeNode.Nodes) { if (group.Type == dataset.GetType()) { treeNodeGroup = group; break; } } if (treeNodeGroup == null) { treeNodeGroup = new TreeNodeGroup(dataset.GetType()); treeNodeGroup.ImageKey = Catalog.FOLDER_CLOSED; treeNodeGroup.SelectedImageKey = Catalog.FOLDER_CLOSED; treeNodeGroup.Text = key; treeNode.Nodes.Add(treeNodeGroup); } // Create New Dataset Node TreeNode treeNodeDataset = this.CreateCatalogNode(treeNodeGroup, dataset); } // Append Subtypes Nodes foreach (Dataset dataset in datasets) { // Is ObjectClass? if (dataset is ObjectClass) { // Cast to ObjectClass ObjectClass objectClass = (ObjectClass)dataset; // Get Subtypes List <Subtype> subtypes = objectClass.GetSubtypes(); if (subtypes.Count == 0) { continue; } // Find Subtype Group Node TreeNodeGroup treeNodeGroup = null; foreach (TreeNodeGroup group in treeNode.Nodes) { if (group.Type == typeof(Subtype)) { treeNodeGroup = group; break; } } if (treeNodeGroup == null) { treeNodeGroup = new TreeNodeGroup(typeof(Subtype)); treeNodeGroup.ImageKey = Catalog.FOLDER_CLOSED; treeNodeGroup.SelectedImageKey = Catalog.FOLDER_CLOSED; treeNodeGroup.Text = Resources.TEXT_SUBTYPE; treeNode.Nodes.Add(treeNodeGroup); } // Add Each Subtype foreach (Subtype subtype in subtypes) { TreeNode treeNodeSubtype = this.CreateCatalogNode(treeNodeGroup, subtype); } } } // Loop for each Domain foreach (Domain domain in domains) { // Get Group Node Name string key = string.Empty; if (domain.GetType() == typeof(DomainCodedValue)) { key = Resources.TEXT_CODED_VALUE; } else if (domain.GetType() == typeof(DomainRange)) { key = Resources.TEXT_RANGE_DOMAIN; } if (string.IsNullOrEmpty(key)) { continue; } // Get Group Node (create if it does not exist) TreeNodeGroup treeNodeGroup = null; foreach (TreeNodeGroup group in treeNode.Nodes) { if (group.Type == domain.GetType()) { treeNodeGroup = group; break; } } if (treeNodeGroup == null) { treeNodeGroup = new TreeNodeGroup(domain.GetType()); treeNodeGroup.ImageKey = Catalog.FOLDER_CLOSED; treeNodeGroup.SelectedImageKey = Catalog.FOLDER_CLOSED; treeNodeGroup.Text = key; treeNode.Nodes.Add(treeNodeGroup); } // Create New Dataset Node TreeNode treeNodeDomain = this.CreateCatalogNode(treeNodeGroup, domain); } // Expand Geodatabase Node treeNode.Expand(); // Traditional Text Sort this.treeView1.Sort(); } else if (this.buttonItemAlphabetical.Checked) { // Loop for each Dataset foreach (Dataset dataset in datasets) { // Create New Dataset Node TreeNode treeNodeDataset = this.CreateCatalogNode(treeNode, dataset); if (dataset is ObjectClass) { // Cast to ObjectClass ObjectClass objectClass = (ObjectClass)dataset; // Get and Add Subtypes List <Subtype> subtypes = objectClass.GetSubtypes(); foreach (Subtype subtype in subtypes) { TreeNode treeNodeSubtype = this.CreateCatalogNode(treeNode, subtype); } } } // Loop for each Domain foreach (Domain domain in domains) { TreeNode treeNodeDomain = this.CreateCatalogNode(treeNode, domain); } // Expand Geodatabase Node treeNode.Expand(); // Traditional Text Sort this.treeView1.Sort(); } // Reselect Previous EsriTable (if any) if (table != null) { if (this.treeView1.Nodes.Count == 1) { //TreeNode treeNode = this.treeView1.Nodes[0]; TreeNode treeNodeFind = this.FindNode(treeNode, table); if (treeNodeFind != null) { treeNodeFind.EnsureVisible(); treeNodeFind.TreeView.SelectedNode = treeNodeFind; } } } // End TreeView Update this.treeView1.EndUpdate(); }
public override void Errors(List<Error> list, EsriTable table) { // Write Base Errors base.Errors(list, table); // Get Topology Topology topology = (Topology)table; // Check for duplicate rules bool duplicate = false; foreach (TopologyRule topologyRule in topology.TopologyRules) { if (topologyRule == this) { continue; } if (this._allOriginSubtypes == topologyRule.AllOriginSubtypes && this._originClassId == topologyRule.OriginClassId && this._originSubtype == topologyRule.OriginSubtype && this._allDestinationSubtypes == topologyRule.AllDestinationSubtypes && this._destinationClassId == topologyRule.DestinationClassId && this._destinationSubtype == topologyRule.DestinationSubtype && this._topologyRuleType == topologyRule.TopologyRuleType) { duplicate = true; break; } } if (duplicate) { string message = string.Format("Duplicate topology rules found"); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // Duplicate Guids bool duplicateGuid = false; foreach (TopologyRule topologyRule in topology.TopologyRules) { if (topologyRule == this) { continue; } if (this._guid == topologyRule.Guid) { duplicateGuid = true; break; } } if (duplicateGuid) { string message = string.Format("Topology Rule Guid [{0}] is not unique", this._guid); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // Check if rule conflict with rules using "All Subtypes" - Origin if (this._allOriginSubtypes) { bool originSubtypeConflict = false; foreach (TopologyRule topologyRule in topology.TopologyRules) { if (topologyRule == this) { continue; } if (topologyRule.AllOriginSubtypes == false && this._originClassId == topologyRule.OriginClassId && this._allDestinationSubtypes == topologyRule.AllDestinationSubtypes && this._destinationClassId == topologyRule.DestinationClassId && this._destinationSubtype == topologyRule.DestinationSubtype && this._topologyRuleType == topologyRule.TopologyRuleType) { originSubtypeConflict = true; break; } } if (originSubtypeConflict) { string message = string.Format("The Topology Rule [{0}] with an Origin 'AllSubtypes' setting conflicts another rule", this._guid); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } } // Check if rule conflict with rules using "All Subtypes" - Destination if (this._allDestinationSubtypes) { bool destinationSubtypeConflict = false; foreach (TopologyRule topologyRule in topology.TopologyRules) { if (topologyRule == this) { continue; } if (topologyRule.AllDestinationSubtypes == false && this._destinationClassId == topologyRule.DestinationClassId && this._allOriginSubtypes == topologyRule.AllOriginSubtypes && this._originClassId == topologyRule.OriginClassId && this._originSubtype == topologyRule.OriginSubtype && this._topologyRuleType == topologyRule.TopologyRuleType) { destinationSubtypeConflict = true; break; } } if (destinationSubtypeConflict) { string message = string.Format("The Topology Rule [{0}] with an Destination 'AllSubtypes' setting conflicts another rule", this._guid); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } } // Valid rules for Origin/Destination Shape Types DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default; SchemaModel schemaModel = diagrammerEnvironment.SchemaModel; // Get Origin and Destination FeatureClasses ObjectClass objectClassOrig = schemaModel.FindObjectClass(this._originClassId); ObjectClass objectClassDest = schemaModel.FindObjectClass(this._destinationClassId); // Check if Origin and Destination ObjectClasses Exist if (objectClassOrig == null) { list.Add(new ErrorObject(this, table, "Origin FeatureClass Does Not Exist", ErrorType.Error)); } if (objectClassDest == null) { list.Add(new ErrorObject(this, table, "Destination FeatureClass Does Not Exist", ErrorType.Error)); } // Check if Origin and Destination Subypes Exist EsriTable tableOrig = schemaModel.FindObjectClassOrSubtype(this._originClassId, this._originSubtype); EsriTable tableDest = schemaModel.FindObjectClassOrSubtype(this._destinationClassId, this._destinationSubtype); if (tableOrig == null) { list.Add(new ErrorObject(this, table, "Origin FeatureClass and/or Subtype Does Not Exist", ErrorType.Error)); } if (tableDest == null) { list.Add(new ErrorObject(this, table, "Destination FeatureClass and/or Subtype Does Not Exist", ErrorType.Error)); } // Get Origin and Destination FeatureClasses FeatureClass featureClassOrig = objectClassOrig as FeatureClass; FeatureClass featureClassDest = objectClassDest as FeatureClass; // These rules MUST have the same origin and destination class/subtype if (featureClassOrig != null && featureClassDest != null && tableOrig != null && tableDest != null) { switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTLineNoOverlap: case esriTopologyRuleType.esriTRTLineNoIntersection: case esriTopologyRuleType.esriTRTLineNoDangles: case esriTopologyRuleType.esriTRTLineNoPseudos: case esriTopologyRuleType.esriTRTLineNoSelfOverlap: case esriTopologyRuleType.esriTRTLineNoSelfIntersect: case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch: case esriTopologyRuleType.esriTRTLineNoMultipart: case esriTopologyRuleType.esriTRTAreaNoGaps: case esriTopologyRuleType.esriTRTAreaNoOverlap: if (this._originClassId != this._destinationClassId || this._originSubtype != this._destinationSubtype) { list.Add(new ErrorObject(this, table, "This rule must have the same origin and destination FeatureClass and Subtype", ErrorType.Error)); } break; default: break; } } // Examine Rule Based on Origin and Destination GeometryType bool ok = false; if (featureClassOrig != null && featureClassDest != null) { switch (featureClassOrig.ShapeType) { case esriGeometryType.esriGeometryPoint: switch (featureClassDest.ShapeType) { case esriGeometryType.esriGeometryPoint: // POINT > POINT switch (this._topologyRuleType) { default: ok = false; break; } break; case esriGeometryType.esriGeometryPolyline: // POINT > POLYLINE switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTPointCoveredByLine: case esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolygon: // POINT > POLYGON switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTPointCoveredByAreaBoundary: case esriTopologyRuleType.esriTRTPointProperlyInsideArea: ok = true; break; default: ok = false; break; } break; } break; case esriGeometryType.esriGeometryPolyline: switch (featureClassDest.ShapeType) { case esriGeometryType.esriGeometryPoint: // POLYLINE > POINT switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTLineEndpointCoveredByPoint: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolyline: // POLYLINE > POLYLINE switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTLineNoOverlap: case esriTopologyRuleType.esriTRTLineNoIntersection: case esriTopologyRuleType.esriTRTLineNoDangles: case esriTopologyRuleType.esriTRTLineNoPseudos: case esriTopologyRuleType.esriTRTLineCoveredByLineClass: case esriTopologyRuleType.esriTRTLineNoOverlapLine: case esriTopologyRuleType.esriTRTLineNoSelfOverlap: case esriTopologyRuleType.esriTRTLineNoSelfIntersect: case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch: case esriTopologyRuleType.esriTRTLineNoMultipart: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolygon: // POLYLINE > POLYGON switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary: ok = true; break; default: ok = false; break; } break; } break; case esriGeometryType.esriGeometryPolygon: switch (featureClassDest.ShapeType) { case esriGeometryType.esriGeometryPoint: // POLYGON > POINT switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTAreaContainPoint: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolyline: // POLYGON > POLYLINE switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByLine: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolygon: // POLYGON > POLYGON switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTAreaNoGaps: case esriTopologyRuleType.esriTRTAreaNoOverlap: case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass: case esriTopologyRuleType.esriTRTAreaAreaCoverEachOther: case esriTopologyRuleType.esriTRTAreaCoveredByArea: case esriTopologyRuleType.esriTRTAreaNoOverlapArea: case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByAreaBoundary: ok = true; break; default: ok = false; break; } break; } break; } } if (!ok) { list.Add(new ErrorObject(this, table, "This rule cannot be added between these FeatureClass geometric types", ErrorType.Error)); } }
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, EsriTable table) { // TODO Evaluated Network Attribute Errors }
public override void Errors(List<Error> list, EsriTable table) { // TODO Add RasterDef Errors // Add Spatial Reference Errors if (this._spatialReference == null) { list.Add(new ErrorObject(this, table, "SpatialReference cannot be null", ErrorType.Error)); } else { this._spatialReference.Errors(list, table); } }
public override void Errors(List<Error> list, EsriTable table) { // TODO: Add Topology Controller Membership Errors }
public override void Errors(List <Error> list, EsriTable table) { // TODO Network Source Direction Errors }
public DiagramEventArgs(EsriTable table, Type type) { this.m_table = table; this.m_type = type; }
public override void Errors(List <Error> list, EsriTable table) { // Write Base Errors base.Errors(list, table); }
public override void Errors(List<Error> list, EsriTable table) { // Check if class/subtype exists EsriTable table2 = DiagrammerEnvironment.Default.SchemaModel.FindObjectClassOrSubtype(this._classID, this._subtypeCode); if (table2 == null) { string message = string.Format("The junction subtype [{0}::{1}] does not exist", this._classID.ToString(), this._subtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } }
public Field(IXPathNavigable path, EsriTable table) : base(path) { // this.SuspendEvents = true; // Get Navigator XPathNavigator navigator = path.CreateNavigator(); // <Name></Name> XPathNavigator navigatorFieldName = navigator.SelectSingleNode("Name"); if (navigatorFieldName != null) { this._name = navigatorFieldName.Value; } // <Type></Type> XPathNavigator navigatorFieldType = navigator.SelectSingleNode("Type"); if (navigatorFieldType != null) { this._fieldType = (esriFieldType)Enum.Parse(typeof(esriFieldType), navigatorFieldType.Value, true); } // <IsNullable></IsNullable> XPathNavigator navigatorFieldIsNullable = navigator.SelectSingleNode("IsNullable"); if (navigatorFieldIsNullable != null) { this._isNullable = navigatorFieldIsNullable.ValueAsBoolean; } // <Length></Length> XPathNavigator navigatorFieldLength = navigator.SelectSingleNode("Length"); if (navigatorFieldLength != null) { this._length = navigatorFieldLength.ValueAsInt; } // <Precision></Precision> XPathNavigator navigatorFieldPrecision = navigator.SelectSingleNode("Precision"); if (navigatorFieldPrecision != null) { this._precision = navigatorFieldPrecision.ValueAsInt; } // <Scale></Scale> XPathNavigator navigatorFieldScale = navigator.SelectSingleNode("Scale"); if (navigatorFieldScale != null) { this._scale = navigatorFieldScale.ValueAsInt; } // <Required></Required> XPathNavigator navigatorFieldRequired = navigator.SelectSingleNode("Required"); if (navigatorFieldRequired != null) { this._required = navigatorFieldRequired.ValueAsBoolean; } // <Editable></Editable> XPathNavigator navigatorFieldEditable = navigator.SelectSingleNode("Editable"); if (navigatorFieldEditable != null) { this._editable = navigatorFieldEditable.ValueAsBoolean; } // <DomainFixed></DomainFixed> XPathNavigator navigatorFieldDomainFixed = navigator.SelectSingleNode("DomainFixed"); if (navigatorFieldDomainFixed != null) { this._domainFixed = navigatorFieldDomainFixed.ValueAsBoolean; } // <AliasName></AliasName> XPathNavigator navigatorFieldAliasName = navigator.SelectSingleNode("AliasName"); if (navigatorFieldAliasName != null) { this._aliasName = navigatorFieldAliasName.Value; } // <GeometryDef></GeometryDef> XPathNavigator navigatorGeometryDef = navigator.SelectSingleNode("GeometryDef"); if (navigatorGeometryDef != null) { this._geometryDef = new GeometryDef(navigatorGeometryDef); } // <ModelName></ModelName> XPathNavigator navigatorFieldModelName = navigator.SelectSingleNode("ModelName"); if (navigatorFieldModelName != null) { this._modelName = navigatorFieldModelName.Value; } // <DefaultValue></DefaultValue> XPathNavigator navigatorFieldDefaultValue = navigator.SelectSingleNode("DefaultValue"); if (navigatorFieldDefaultValue != null) { this._defaultValue = navigatorFieldDefaultValue.Value; } // <Domain></Domain> XPathNavigator navigatorFieldDomain= navigator.SelectSingleNode("Domain/DomainName"); if (navigatorFieldDomain != null) { this._domain = navigatorFieldDomain.Value; } // <RasterDef></RasterDef> XPathNavigator navigatorRasterDef = navigator.SelectSingleNode("RasterDef"); if (navigatorRasterDef != null) { this._rasterDef = new RasterDef(navigatorRasterDef); } // Initialize Text this.UpdateText(); // Set Element Properties this.Image = new Crainiate.ERM4.Image("Resource.publicfield.gif", "Crainiate.ERM4.Component"); // this.SuspendEvents = false; }
public override void Errors(List<Error> list, EsriTable table) { // TODO Network Attribute Parameter Errors }
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 TableEventArgs(EsriTable table) { this._table = table; }
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 override void Errors(List <Error> list, EsriTable table) { // TODO: Add Topology Controller Membership Errors }
public TableEventArgs(EsriTable table) { this._table = table; }
public override void Errors(List<Error> list, EsriTable table) { // TODO Terrain Pyramid Errors }
public override void Errors(List<Error> list, EsriTable table) { // TODO TerrainDataSource Errors }
public override void Errors(List<Error> list, EsriTable table) { // TODO Network Source Direction Errors }
public override void Errors(List <Error> list, EsriTable table) { // TODO Network Attribute Parameter Errors }
public override void Errors(List <Error> list, EsriTable table) { // Write Base Errors base.Errors(list, table); // Get Topology Topology topology = (Topology)table; // Check for duplicate rules bool duplicate = false; foreach (TopologyRule topologyRule in topology.TopologyRules) { if (topologyRule == this) { continue; } if (this._allOriginSubtypes == topologyRule.AllOriginSubtypes && this._originClassId == topologyRule.OriginClassId && this._originSubtype == topologyRule.OriginSubtype && this._allDestinationSubtypes == topologyRule.AllDestinationSubtypes && this._destinationClassId == topologyRule.DestinationClassId && this._destinationSubtype == topologyRule.DestinationSubtype && this._topologyRuleType == topologyRule.TopologyRuleType) { duplicate = true; break; } } if (duplicate) { string message = string.Format("Duplicate topology rules found"); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // Duplicate Guids bool duplicateGuid = false; foreach (TopologyRule topologyRule in topology.TopologyRules) { if (topologyRule == this) { continue; } if (this._guid == topologyRule.Guid) { duplicateGuid = true; break; } } if (duplicateGuid) { string message = string.Format("Topology Rule Guid [{0}] is not unique", this._guid); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // Check if rule conflict with rules using "All Subtypes" - Origin if (this._allOriginSubtypes) { bool originSubtypeConflict = false; foreach (TopologyRule topologyRule in topology.TopologyRules) { if (topologyRule == this) { continue; } if (topologyRule.AllOriginSubtypes == false && this._originClassId == topologyRule.OriginClassId && this._allDestinationSubtypes == topologyRule.AllDestinationSubtypes && this._destinationClassId == topologyRule.DestinationClassId && this._destinationSubtype == topologyRule.DestinationSubtype && this._topologyRuleType == topologyRule.TopologyRuleType) { originSubtypeConflict = true; break; } } if (originSubtypeConflict) { string message = string.Format("The Topology Rule [{0}] with an Origin 'AllSubtypes' setting conflicts another rule", this._guid); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } } // Check if rule conflict with rules using "All Subtypes" - Destination if (this._allDestinationSubtypes) { bool destinationSubtypeConflict = false; foreach (TopologyRule topologyRule in topology.TopologyRules) { if (topologyRule == this) { continue; } if (topologyRule.AllDestinationSubtypes == false && this._destinationClassId == topologyRule.DestinationClassId && this._allOriginSubtypes == topologyRule.AllOriginSubtypes && this._originClassId == topologyRule.OriginClassId && this._originSubtype == topologyRule.OriginSubtype && this._topologyRuleType == topologyRule.TopologyRuleType) { destinationSubtypeConflict = true; break; } } if (destinationSubtypeConflict) { string message = string.Format("The Topology Rule [{0}] with an Destination 'AllSubtypes' setting conflicts another rule", this._guid); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } } // Valid rules for Origin/Destination Shape Types DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default; SchemaModel schemaModel = diagrammerEnvironment.SchemaModel; // Get Origin and Destination FeatureClasses ObjectClass objectClassOrig = schemaModel.FindObjectClass(this._originClassId); ObjectClass objectClassDest = schemaModel.FindObjectClass(this._destinationClassId); // Check if Origin and Destination ObjectClasses Exist if (objectClassOrig == null) { list.Add(new ErrorObject(this, table, "Origin FeatureClass Does Not Exist", ErrorType.Error)); } if (objectClassDest == null) { list.Add(new ErrorObject(this, table, "Destination FeatureClass Does Not Exist", ErrorType.Error)); } // Check if Origin and Destination Subypes Exist EsriTable tableOrig = schemaModel.FindObjectClassOrSubtype(this._originClassId, this._originSubtype); EsriTable tableDest = schemaModel.FindObjectClassOrSubtype(this._destinationClassId, this._destinationSubtype); if (tableOrig == null) { list.Add(new ErrorObject(this, table, "Origin FeatureClass and/or Subtype Does Not Exist", ErrorType.Error)); } if (tableDest == null) { list.Add(new ErrorObject(this, table, "Destination FeatureClass and/or Subtype Does Not Exist", ErrorType.Error)); } // Get Origin and Destination FeatureClasses FeatureClass featureClassOrig = objectClassOrig as FeatureClass; FeatureClass featureClassDest = objectClassDest as FeatureClass; // These rules MUST have the same origin and destination class/subtype if (featureClassOrig != null && featureClassDest != null && tableOrig != null && tableDest != null) { switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTLineNoOverlap: case esriTopologyRuleType.esriTRTLineNoIntersection: case esriTopologyRuleType.esriTRTLineNoDangles: case esriTopologyRuleType.esriTRTLineNoPseudos: case esriTopologyRuleType.esriTRTLineNoSelfOverlap: case esriTopologyRuleType.esriTRTLineNoSelfIntersect: case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch: case esriTopologyRuleType.esriTRTLineNoMultipart: case esriTopologyRuleType.esriTRTAreaNoGaps: case esriTopologyRuleType.esriTRTAreaNoOverlap: if (this._originClassId != this._destinationClassId || this._originSubtype != this._destinationSubtype) { list.Add(new ErrorObject(this, table, "This rule must have the same origin and destination FeatureClass and Subtype", ErrorType.Error)); } break; default: break; } } // Examine Rule Based on Origin and Destination GeometryType bool ok = false; if (featureClassOrig != null && featureClassDest != null) { switch (featureClassOrig.ShapeType) { case esriGeometryType.esriGeometryPoint: switch (featureClassDest.ShapeType) { case esriGeometryType.esriGeometryPoint: // POINT > POINT switch (this._topologyRuleType) { default: ok = false; break; } break; case esriGeometryType.esriGeometryPolyline: // POINT > POLYLINE switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTPointCoveredByLine: case esriTopologyRuleType.esriTRTPointCoveredByLineEndpoint: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolygon: // POINT > POLYGON switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTPointCoveredByAreaBoundary: case esriTopologyRuleType.esriTRTPointProperlyInsideArea: ok = true; break; default: ok = false; break; } break; } break; case esriGeometryType.esriGeometryPolyline: switch (featureClassDest.ShapeType) { case esriGeometryType.esriGeometryPoint: // POLYLINE > POINT switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTLineEndpointCoveredByPoint: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolyline: // POLYLINE > POLYLINE switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTLineNoOverlap: case esriTopologyRuleType.esriTRTLineNoIntersection: case esriTopologyRuleType.esriTRTLineNoDangles: case esriTopologyRuleType.esriTRTLineNoPseudos: case esriTopologyRuleType.esriTRTLineCoveredByLineClass: case esriTopologyRuleType.esriTRTLineNoOverlapLine: case esriTopologyRuleType.esriTRTLineNoSelfOverlap: case esriTopologyRuleType.esriTRTLineNoSelfIntersect: case esriTopologyRuleType.esriTRTLineNoIntersectOrInteriorTouch: case esriTopologyRuleType.esriTRTLineNoMultipart: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolygon: // POLYLINE > POLYGON switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTLineCoveredByAreaBoundary: ok = true; break; default: ok = false; break; } break; } break; case esriGeometryType.esriGeometryPolygon: switch (featureClassDest.ShapeType) { case esriGeometryType.esriGeometryPoint: // POLYGON > POINT switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTAreaContainPoint: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolyline: // POLYGON > POLYLINE switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByLine: ok = true; break; default: ok = false; break; } break; case esriGeometryType.esriGeometryPolygon: // POLYGON > POLYGON switch (this._topologyRuleType) { case esriTopologyRuleType.esriTRTAreaNoGaps: case esriTopologyRuleType.esriTRTAreaNoOverlap: case esriTopologyRuleType.esriTRTAreaCoveredByAreaClass: case esriTopologyRuleType.esriTRTAreaAreaCoverEachOther: case esriTopologyRuleType.esriTRTAreaCoveredByArea: case esriTopologyRuleType.esriTRTAreaNoOverlapArea: case esriTopologyRuleType.esriTRTAreaBoundaryCoveredByAreaBoundary: ok = true; break; default: ok = false; break; } break; } break; } } if (!ok) { list.Add(new ErrorObject(this, table, "This rule cannot be added between these FeatureClass geometric types", ErrorType.Error)); } }
public EsriTable(EsriTable prototype) : base(prototype) { }
public EsriTable(EsriTable prototype) : base(prototype) { }
public override void Errors(List <Error> list, EsriTable table) { // Write Base Errors base.Errors(list, table); // From Class ID and SubtypeCode EsriTable table2 = DiagrammerEnvironment.Default.SchemaModel.FindObjectClassOrSubtype(this._fromClassID, this._fromEdgeSubtypeCode); if (table2 == null) { string message = string.Format("Edge Connectivity Rule [{0}]: Can not identify the from edge [{1}::{0}]", this.RuleId.ToString(), this._fromClassID.ToString(), this._fromEdgeSubtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // To Class ID and SubtypeCode EsriTable table3 = DiagrammerEnvironment.Default.SchemaModel.FindObjectClassOrSubtype(this._toClassID, this._toEdgeSubtypeCode); if (table3 == null) { string message = string.Format("Edge Connectivity Rule [{0}]: Can not identify the to edge [{1}::{0}]", this.RuleId.ToString(), this._toClassID.ToString(), this._toEdgeSubtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // Default Class ID and SubtypeCode EsriTable table4 = DiagrammerEnvironment.Default.SchemaModel.FindObjectClassOrSubtype(this._defaultJunctionID, this._defaultJunctionSubtypeCode); if (table4 == null) { string message = string.Format("Edge Connectivity Rule [{0}]: Can not identify the default junction [{1}::{0}]", this.RuleId.ToString(), this._defaultJunctionID.ToString(), this._defaultJunctionSubtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } else { bool found = false; foreach (JunctionSubtype junctionSubtype in this._junctionSubtypes) { if (junctionSubtype.ClassID == this._defaultJunctionID && junctionSubtype.SubtypeCode == this._defaultJunctionSubtypeCode) { found = true; break; } } if (!found) { string message = string.Format("Edge Connectivity Rule [{0}]: The default junction [{1}::{0}] in not contained in the junction list", this.RuleId.ToString(), this._defaultJunctionID.ToString(), this._defaultJunctionSubtypeCode.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } } // Junction Subtype if (this._junctionSubtypes.Count == 0) { string message = string.Format("Edge Connectivity Rule [{0}]: The rule must at least one junction defined", this.RuleId.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } foreach (JunctionSubtype junctionSubtype in this._junctionSubtypes) { junctionSubtype.Errors(list, table); } }
public override void Errors(List<Error> list, EsriTable table) { // TODO : HelpString contains invalid characters // TODO : Rule Id less than -1 }
public override void Errors(List<Error> list, EsriTable table) { // Key cannot be empty if (string.IsNullOrEmpty(this._key)) { list.Add(new ErrorObject(this, table, "Property Key cannot be empty", ErrorType.Error)); } // Type cannot be empty if (string.IsNullOrEmpty(this._type)) { list.Add(new ErrorObject(this, table, "Property Type cannot be empty", ErrorType.Error)); } // [Warning] if (string.IsNullOrEmpty(this._value)) { list.Add(new ErrorObject(this, table, "Property Value is empty", ErrorType.Warning)); } }
public override void Errors(List <Error> list, EsriTable table) { // TODO : HelpString contains invalid characters // TODO : Rule Id less than -1 }
public ErrorTable(EsriTable table, string description, ErrorType errorType) : base(description, errorType) { this.m_table = table; }
public override void Errors(List <Error> list, EsriTable table) { // TODO Shield Errors }
private void MenuItem_Activate(object sender, EventArgs e) { try { // // Error List Context Menu // if (sender == this.menuButtonItemScroll) { // Can only zoom to one item if (this.listViewErrorList.SelectedItems.Count != 1) { return; } // Get EsriTable containing the error ListViewItemError item = (ListViewItemError)this.listViewErrorList.SelectedItems[0]; EsriTable table = null; if (item.Error is ErrorTable) { ErrorTable errorTable = (ErrorTable)item.Error; table = errorTable.Table; } else if (item.Error is ErrorTableRow) { ErrorTableRow errorTableRow = (ErrorTableRow)item.Error; EsriTableRow esriTableRow = (EsriTableRow)errorTableRow.TableRow; table = (EsriTable)esriTableRow.Table; } else if (item.Error is ErrorObject) { ErrorObject errorObject = (ErrorObject)item.Error; table = errorObject.Table; } if (table == null) { return; } // Get Containing Model EsriModel model = (EsriModel)table.Container; // Scroll to Table model.ScrollToElement(table); // Flash Table table.Flash(); } else if (sender == this.menuButtonItemSelect) { // Can only zoom to one item if (this.listViewErrorList.SelectedItems.Count == 0) { return; } foreach (ListViewItemError item in this.listViewErrorList.SelectedItems) { EsriModel model = null; if (item.Error is ErrorTable) { ErrorTable errorTable = (ErrorTable)item.Error; EsriTable table = errorTable.Table; model = (EsriModel)table.Container; } else if (item.Error is ErrorTableRow) { ErrorTableRow errorTableRow = (ErrorTableRow)item.Error; EsriTableRow esriTableRow = (EsriTableRow)errorTableRow.TableRow; EsriTable table = (EsriTable)esriTableRow.Table; model = (EsriModel)table.Container; } else if (item.Error is ErrorObject) { ErrorObject errorObject = (ErrorObject)item.Error; EsriTable table = errorObject.Table; model = (EsriModel)table.Container; } if (model == null) { continue; } // Clear Model Selection model.SelectElements(false); } // foreach (ListViewItemError item in this.listViewErrorList.SelectedItems) { // Get Table EsriTable table = null; if (item.Error is ErrorTable) { ErrorTable errorTable = (ErrorTable)item.Error; table = errorTable.Table; } else if (item.Error is ErrorTableRow) { ErrorTableRow errorTableRow = (ErrorTableRow)item.Error; EsriTableRow esriTableRow = (EsriTableRow)errorTableRow.TableRow; table = (EsriTable)esriTableRow.Table; } else if (item.Error is ErrorObject) { ErrorObject errorObject = (ErrorObject)item.Error; table = errorObject.Table; } if (table == null) { continue; } // Flash Table table.Selected = true; } } else if (sender == this.menuButtonItemFlashError) { // Can only zoom to one item if (this.listViewErrorList.SelectedItems.Count == 0) { return; } // foreach (ListViewItemError item in this.listViewErrorList.SelectedItems) { // Get Table EsriTable table = null; if (item.Error is ErrorTable) { ErrorTable errorTable = (ErrorTable)item.Error; table = errorTable.Table; } else if (item.Error is ErrorTableRow) { ErrorTableRow errorTableRow = (ErrorTableRow)item.Error; EsriTableRow esriTableRow = (EsriTableRow)errorTableRow.TableRow; table = (EsriTable)esriTableRow.Table; } else if (item.Error is ErrorObject) { ErrorObject errorObject = (ErrorObject)item.Error; table = errorObject.Table; } if (table == null) { continue; } // Flash Table table.Flash(); } } else if (sender == this.menuButtonItemClearError) { // Remove Selected Items foreach (ListViewItemError item in this.listViewErrorList.SelectedItems) { if (this.m_errors.Contains(item.Error)) { this.m_errors.Remove(item.Error); } } // Refresh Error List this.RefreshErrorList(); } else if (sender == menuButtonItemClearAllErrors) { // Remove All Errors this.m_errors.Clear(); // Refresh Error List this.RefreshErrorList(); } // // Validator Dropdown Menu // else if (sender == this.menuButtonItemPGdb) { WorkspaceValidator.Default.Validator = new PersonalGeodatabaseValidator(); } else if (sender == this.menuButtonItemFGdb) { WorkspaceValidator.Default.Validator = new FileGeodatabaseValidator(); } else if (sender == this.menuButtonItemSelectGeodatabase) { // Create GxObjectFilter for GxDialog IGxObjectFilter gxObjectFilter = new GxFilterWorkspacesClass(); // Create GxDialog IGxDialog gxDialog = new GxDialogClass(); gxDialog.AllowMultiSelect = false; gxDialog.ButtonCaption = Resources.TEXT_SELECT; gxDialog.ObjectFilter = gxObjectFilter; gxDialog.RememberLocation = true; gxDialog.Title = Resources.TEXT_SELECT_EXISTING_GEODATABASE; // Declare Enumerator to hold selected objects IEnumGxObject enumGxObject = null; // Open Dialog if (!gxDialog.DoModalOpen(0, out enumGxObject)) { return; } if (enumGxObject == null) { return; } // Get Selected Object (if any) IGxObject gxObject = enumGxObject.Next(); if (gxObject == null) { return; } if (!gxObject.IsValid) { return; } // Get GxDatabase if (!(gxObject is IGxDatabase)) { return; } IGxDatabase gxDatabase = (IGxDatabase)gxObject; // Get Workspace IWorkspace workspace = gxDatabase.Workspace; if (workspace == null) { return; } // Get Workspace Factory IWorkspaceFactory workspaceFactory = workspace.WorkspaceFactory; if (workspaceFactory == null) { return; } // Get Workspace Factory ID IUID uid = workspaceFactory.GetClassID(); string guid = uid.Value.ToString().ToUpper(); switch (guid) { case EsriRegistry.GEODATABASE_PERSONAL: WorkspaceValidator.Default.Validator = new PersonalGeodatabaseValidator(workspace); break; case EsriRegistry.GEODATABASE_FILE: WorkspaceValidator.Default.Validator = new FileGeodatabaseValidator(workspace); break; case EsriRegistry.GEODATABASE_SDE: WorkspaceValidator.Default.Validator = new SdeValidator(workspace); break; default: break; } } else if ((sender is MenuButtonItem) && (((MenuButtonItem)sender).Parent == this.menuButtonItemSdeConnection)) { MenuButtonItem item = (MenuButtonItem)sender; if (item.Tag == null) { return; } WorkspaceValidator.Default.Validator = new SdeValidator(item.Tag.ToString()); } } catch (Exception ex) { ExceptionDialog.HandleException(ex); } }
public override void Errors(List<Error> list, EsriTable table) { // Export SpatialReference Errors if (this._spatialReference != null) { this._spatialReference.Errors(list, table); } // AvgNumPoints if (this._avgNumPoints < 0) { // Must be positive list.Add(new ErrorObject(this, table, "AvgNumPoints must be positive", ErrorType.Error)); } // Check GridSize Configuration if (this._gridSize0 == -1 && this._gridSize1 == -1 && this._gridSize2 == -1) { // OK } else if (this._gridSize0 != -1 && this._gridSize1 == -1 && this._gridSize2 == -1) { // OK } else if (this._gridSize0 != -1 && this._gridSize1 != -1 && this._gridSize2 == -1) { // OK if (this._gridSize0 > this._gridSize1) { list.Add(new ErrorObject(this, table, "GridSize0 cannot be larger than GridSize1", ErrorType.Error)); } } else if (this._gridSize0 != -1 && this._gridSize1 != -1 && this._gridSize2 != -1) { // OK if (this._gridSize0 > this._gridSize1) { list.Add(new ErrorObject(this, table, "GridSize0 cannot be larger than GridSize1", ErrorType.Error)); } if (this._gridSize1 > this._gridSize2) { list.Add(new ErrorObject(this, table, "GridSize1 cannot be larger than GridSize2", ErrorType.Error)); } } else { // Invalid Combination string message = string.Format( "Grid configuration '{0}'/'{1}'/'{2}' is invalid", this._gridSize0.ToString(), this._gridSize1.ToString(), this._gridSize2.ToString()); list.Add(new ErrorObject(this, table, message, ErrorType.Error)); } // GridSize0 if (this._gridSize0 != -1){ if (this._gridSize0 < 0) { // Must be greater than zero list.Add(new ErrorObject(this, table, "GridSize0 must be greater than (or equal to) zero", ErrorType.Error)); } } // GridSize1 if (this._gridSize1 != -1) { if (this._gridSize1 < 0) { // Must be positive list.Add(new ErrorObject(this, table, "GridSize1 must be zero or a positive", ErrorType.Error)); } } // GridSize2 if (this._gridSize2 != -1) { if (this._gridSize2 < 0) { // Must be positive list.Add(new ErrorObject(this, table, "GridSize2 must be zero or a positive", ErrorType.Error)); } } }
public override void Errors(List<Error> list, EsriTable table) { // Add Spatial Reference Errors if (this._spatialReference == null) { list.Add(new ErrorObject(this, table, "SpatialReference cannot be null", ErrorType.Error)); } else { this._spatialReference.Errors(list, table); } // XMin > XMax if (this._xMin > this._xMax) { list.Add(new ErrorObject(this, table, "XMin is larger thatn XMax", ErrorType.Error)); } // YMin < YMax if (this._yMin > this._yMax) { list.Add(new ErrorObject(this, table, "YMin is larger thatn YMax", ErrorType.Error)); } }