private void CollectionForm_Closing(object sender, CancelEventArgs e) { // Get Collection Form CollectionForm collectionForm = (CollectionForm)sender; // Get edited collection object object editValue = collectionForm.EditValue; // Check if collection edits have been OK'ed or Canceled DialogResult dialogResult = collectionForm.DialogResult; switch (dialogResult) { case DialogResult.OK: // Get Schema Model DiagrammerEnvironment d = DiagrammerEnvironment.Default; SchemaModel schemaModel = d.SchemaModel; // Suspect Model Draws schemaModel.Suspend(); // Get TableItems Collection TableItems tableItems = (TableItems)editValue; // Store items in new List List <TableItem> list = new List <TableItem>(); foreach (TableItem tableItem in tableItems) { list.Add(tableItem); } // Clear TableItems Collection tableItems.Clear(); // Re-add all items. foreach (TableItem tableItem in list) { // If the Table property is not set then use TableItems::Add to append the item. // This will ensure that Table, GradientColor, Indent properties are correctly set. // This will also reset the height of the TableItems collection. if (tableItem.Indent == 0f) { tableItems.Add(tableItem); } else { ((IList)tableItems).Add(tableItem); } } // Refresh Model schemaModel.Resume(); schemaModel.Refresh(); break; case DialogResult.Cancel: default: // Collection edits are canceled. No need to refresh. break; } }
// // PUBLIC METHODS // public override void OpenModel() { List <EsriShape <FeatureClass> > listFeatureClassFrom = new List <EsriShape <FeatureClass> >(); List <EsriShape <FeatureClass> > listFeatureClassTo = new List <EsriShape <FeatureClass> >(); List <EsriShape <Subtype> > listSubtypeFrom = new List <EsriShape <Subtype> >(); List <EsriShape <Subtype> > listSubtypeTo = new List <EsriShape <Subtype> >(); // Exit if invalid if (this._geometricNetwork == null) { return; } // Suspend Model if (ModelSettings.Default.EnableUndoRedo) { this.UndoList.Suspend(); } this.Suspend(); this.SuspendEvents = true; // Get SchemaModel SchemaModel schemaModel = (SchemaModel)this._geometricNetwork.Container; // Get Parent FeatureDataset Dataset parent = this._geometricNetwork.GetParent(); if (parent == null) { return; } FeatureDataset featureDataset = parent as FeatureDataset; if (featureDataset == null) { return; } // Add From and To FeatureDatasets EsriShape <FeatureDataset> featureDataset1 = new EsriShape <FeatureDataset>(featureDataset); EsriShape <FeatureDataset> featureDataset2 = new EsriShape <FeatureDataset>(featureDataset); this.Shapes.Add(this.Shapes.CreateKey(), featureDataset1); this.Shapes.Add(this.Shapes.CreateKey(), featureDataset2); // Add all Child FeatureClasses foreach (Dataset dataset in featureDataset.GetChildren()) { if (dataset.GetType() != typeof(FeatureClass)) { continue; } // Get FeatureClass FeatureClass featureClass = (FeatureClass)dataset; // Only allow Simle and Complex Edges switch (featureClass.FeatureType) { case esriFeatureType.esriFTSimpleEdge: case esriFeatureType.esriFTComplexEdge: case esriFeatureType.esriFTSimpleJunction: break; default: continue; } // Only continue if FeatureClass belongs to the GeometricNetwork bool participate = false; foreach (ControllerMembership controller in featureClass.ControllerMemberships) { if (controller is GeometricNetworkControllerMembership) { GeometricNetworkControllerMembership geometricNetworkControllerMembership = (GeometricNetworkControllerMembership)controller; if (geometricNetworkControllerMembership.GeometricNetworkName == this._geometricNetwork.Name) { participate = true; break; } } } if (!participate) { continue; } // Get Subtypes List <Subtype> subtypes = featureClass.GetSubtypes(); switch (featureClass.FeatureType) // (featureClass.CLSID) { { case esriFeatureType.esriFTSimpleEdge: // EsriRegistry.CLASS_SIMPLEEDGE: case esriFeatureType.esriFTComplexEdge: // EsriRegistry.CLASS_COMPLEXEDGE: // Add From FetaureClasses and Subtypes EsriShape <FeatureClass> featureClass1 = new EsriShape <FeatureClass>(featureClass); this.Shapes.Add(this.Shapes.CreateKey(), featureClass1); listFeatureClassFrom.Add(featureClass1); // Add Line from FeatureDataset to FeatureClass Arrow arrow1 = new Arrow(); arrow1.BorderColor = ModelSettings.Default.DisabledLined; arrow1.DrawBackground = false; Line line1 = new Line(featureDataset1, featureClass1); line1.End.AllowMove = false; line1.End.Marker = arrow1; line1.Start.AllowMove = false; line1.BorderColor = ModelSettings.Default.DisabledLined; this.Lines.Add(this.Lines.CreateKey(), line1); // Add Subtypes and Link to FeatureClass foreach (Subtype subtype in subtypes) { EsriShape <Subtype> sub = new EsriShape <Subtype>(subtype); this.Shapes.Add(this.Shapes.CreateKey(), sub); listSubtypeFrom.Add(sub); Arrow arrow3 = new Arrow(); arrow3.BorderColor = ModelSettings.Default.DisabledLined; arrow3.DrawBackground = false; Line line = new Line(featureClass1, sub); line.End.AllowMove = false; line.End.Marker = arrow3; line.Start.AllowMove = false; line.BorderColor = ModelSettings.Default.DisabledLined; this.Lines.Add(this.Lines.CreateKey(), line); } break; case esriFeatureType.esriFTSimpleJunction: // EsriRegistry.CLASS_SIMPLEJUNCTION: // Add To FetaureClasses and Subtypes EsriShape <FeatureClass> featureClass2 = new EsriShape <FeatureClass>(featureClass); this.Shapes.Add(this.Shapes.CreateKey(), featureClass2); listFeatureClassTo.Add(featureClass2); // Add Line from FeatureDataset to FeatureClass Arrow arrow2 = new Arrow(); arrow2.BorderColor = ModelSettings.Default.DisabledLined; arrow2.DrawBackground = false; Line line2 = new Line(featureClass2, featureDataset2); line2.End.AllowMove = false; line2.Start.AllowMove = false; line2.Start.Marker = arrow2; line2.BorderColor = ModelSettings.Default.DisabledLined; this.Lines.Add(this.Lines.CreateKey(), line2); // Add Subtyes and Link to FeatureClasses foreach (Subtype subtype in subtypes) { EsriShape <Subtype> sub = new EsriShape <Subtype>(subtype); this.Shapes.Add(this.Shapes.CreateKey(), sub); listSubtypeTo.Add(sub); Arrow arrow4 = new Arrow(); arrow4.BorderColor = ModelSettings.Default.DisabledLined; arrow4.DrawBackground = false; Line line = new Line(sub, featureClass2); line.End.AllowMove = false; line.Start.Marker = arrow4; line.Start.AllowMove = false; line.BorderColor = ModelSettings.Default.DisabledLined; this.Lines.Add(this.Lines.CreateKey(), line); } break; } } // Loop Through All Connectivity Rules foreach (ConnectivityRule connectivityRule in this._geometricNetwork.ConnectivityRules) { // Continue only if Edge Connectivity Rule if (!(connectivityRule is JunctionConnectivityRule)) { continue; } // Get Edge Connectivity Rule JunctionConnectivityRule junctionConnectivityRule = (JunctionConnectivityRule)connectivityRule; // Origin Table EsriTable origin = schemaModel.FindObjectClassOrSubtype( junctionConnectivityRule.EdgeClassID, junctionConnectivityRule.EdgeSubtypeCode); // Destination Table EsriTable destination = schemaModel.FindObjectClassOrSubtype( junctionConnectivityRule.JunctionClassID, junctionConnectivityRule.SubtypeCode); // Origin and Destination Shapes Shape shapeOrigin = null; Shape shapeDestiantion = null; // Find Origin Shape in Diagram foreach (EsriShape <FeatureClass> f in listFeatureClassFrom) { if (f.Parent == origin) { shapeOrigin = f; break; } } if (shapeOrigin == null) { foreach (EsriShape <Subtype> s in listSubtypeFrom) { if (s.Parent == origin) { shapeOrigin = s; break; } } } // Find Destination Shape in Diagram foreach (EsriShape <FeatureClass> f in listFeatureClassTo) { if (f.Parent == destination) { shapeDestiantion = f; break; } } if (shapeDestiantion == null) { foreach (EsriShape <Subtype> s in listSubtypeTo) { if (s.Parent == destination) { shapeDestiantion = s; break; } } } // Skip if Origin and Destination Shapes not found if (shapeOrigin == null || shapeDestiantion == null) { continue; } EsriLine <JunctionConnectivityRule> line2 = new EsriLine <JunctionConnectivityRule>(junctionConnectivityRule, shapeOrigin, shapeDestiantion); this.Lines.Add(this.Lines.CreateKey(), line2); } // Perform Layout this.ExecuteLayout(typeof(HierarchicalLayout), true); // Resume and Refresh Model this.SuspendEvents = false; this.Resume(); if (ModelSettings.Default.EnableUndoRedo) { this.UndoList.Resume(); } this.Refresh(); }
// // PUBLIC METHODS // public override void OpenModel() { // Create Origin and Destination Lists List <EsriShape <FeatureClass> > listFeatureClassFrom = new List <EsriShape <FeatureClass> >(); List <EsriShape <FeatureClass> > listFeatureClassTo = new List <EsriShape <FeatureClass> >(); List <EsriShape <Subtype> > listSubtypeFrom = new List <EsriShape <Subtype> >(); List <EsriShape <Subtype> > listSubtypeTo = new List <EsriShape <Subtype> >(); // Exit if invalid if (this._topology == null) { return; } // Suspend Model if (ModelSettings.Default.EnableUndoRedo) { this.UndoList.Suspend(); } this.Suspend(); this.SuspendEvents = true; // Get SchemaModel SchemaModel schemaModel = (SchemaModel)this._topology.Container; // Get Parent FeatureDataset Dataset parent = this._topology.GetParent(); if (parent == null) { return; } FeatureDataset featureDataset = parent as FeatureDataset; if (featureDataset == null) { return; } // Add From and To FeatureDatasets EsriShape <FeatureDataset> featureDataset1 = new EsriShape <FeatureDataset>(featureDataset); EsriShape <FeatureDataset> featureDataset2 = new EsriShape <FeatureDataset>(featureDataset); this.Shapes.Add(this.Shapes.CreateKey(), featureDataset1); this.Shapes.Add(this.Shapes.CreateKey(), featureDataset2); // Add all Child FeatureClasses foreach (Dataset dataset in featureDataset.GetChildren()) { if (dataset.GetType() != typeof(FeatureClass)) { continue; } // Get FeatureClass FeatureClass featureClass = (FeatureClass)dataset; // Only continue if FeatureClass belongs to the Topology bool participate = false; foreach (ControllerMembership controller in featureClass.ControllerMemberships) { if (controller is TopologyControllerMembership) { TopologyControllerMembership topologyControllerMembership = (TopologyControllerMembership)controller; if (topologyControllerMembership.TopologyName == this._topology.Name) { participate = true; break; } } } if (!participate) { continue; } // Get Subtypes List <Subtype> subtypes = featureClass.GetSubtypes(); // Add From FetaureClasses and Subtypes EsriShape <FeatureClass> featureClass1 = new EsriShape <FeatureClass>(featureClass); this.Shapes.Add(this.Shapes.CreateKey(), featureClass1); listFeatureClassFrom.Add(featureClass1); // Add Line from FeatureDataset to FeatureClass Arrow arrow1 = new Arrow(); arrow1.BorderColor = ModelSettings.Default.DisabledLined; arrow1.DrawBackground = false; Line line1 = new Line(featureDataset1, featureClass1); line1.End.AllowMove = false; line1.End.Marker = arrow1; line1.Start.AllowMove = false; line1.BorderColor = ModelSettings.Default.DisabledLined; this.Lines.Add(this.Lines.CreateKey(), line1); // Add Subtypes and Link to FeatureClass foreach (Subtype subtype in subtypes) { EsriShape <Subtype> sub = new EsriShape <Subtype>(subtype); this.Shapes.Add(this.Shapes.CreateKey(), sub); listSubtypeFrom.Add(sub); Arrow arrow3 = new Arrow(); arrow3.BorderColor = ModelSettings.Default.DisabledLined; arrow3.DrawBackground = false; Line line = new Line(featureClass1, sub); line.End.AllowMove = false; line.End.Marker = arrow3; line.Start.AllowMove = false; line.BorderColor = ModelSettings.Default.DisabledLined; this.Lines.Add(this.Lines.CreateKey(), line); } // Add To FetaureClasses and Subtypes EsriShape <FeatureClass> featureClass2 = new EsriShape <FeatureClass>(featureClass); this.Shapes.Add(this.Shapes.CreateKey(), featureClass2); listFeatureClassTo.Add(featureClass2); // Add Line from FeatureDataset to FeatureClass Arrow arrow2 = new Arrow(); arrow2.BorderColor = ModelSettings.Default.DisabledLined; arrow2.DrawBackground = false; Line line2 = new Line(featureClass2, featureDataset2); line2.End.AllowMove = false; line2.Start.AllowMove = false; line2.Start.Marker = arrow2; line2.BorderColor = ModelSettings.Default.DisabledLined; this.Lines.Add(this.Lines.CreateKey(), line2); // Add Subtyes and Link to FeatureClasses foreach (Subtype subtype in subtypes) { EsriShape <Subtype> sub = new EsriShape <Subtype>(subtype); this.Shapes.Add(this.Shapes.CreateKey(), sub); listSubtypeTo.Add(sub); Arrow arrow4 = new Arrow(); arrow4.BorderColor = ModelSettings.Default.DisabledLined; arrow4.DrawBackground = false; Line line = new Line(sub, featureClass2); line.End.AllowMove = false; line.Start.Marker = arrow4; line.Start.AllowMove = false; line.BorderColor = ModelSettings.Default.DisabledLined; this.Lines.Add(this.Lines.CreateKey(), line); } } // Loop Through All Connectivity Rules foreach (TopologyRule topologyRule in this._topology.TopologyRules) { // Origin Table EsriTable origin = null; if (topologyRule.AllOriginSubtypes) { origin = schemaModel.FindObjectClass(topologyRule.OriginClassId); } else { origin = schemaModel.FindObjectClassOrSubtype( topologyRule.OriginClassId, topologyRule.OriginSubtype); } // Destination Table EsriTable destination = null; if (topologyRule.AllDestinationSubtypes) { destination = schemaModel.FindObjectClass(topologyRule.DestinationClassId); } else { destination = schemaModel.FindObjectClassOrSubtype( topologyRule.DestinationClassId, topologyRule.DestinationSubtype); } // Origin and Destination Shapes Shape shapeOrigin = null; Shape shapeDestiantion = null; // Find Origin Shape in Diagram foreach (EsriShape <FeatureClass> f in listFeatureClassFrom) { if (f.Parent == origin) { shapeOrigin = f; break; } } if (shapeOrigin == null) { foreach (EsriShape <Subtype> s in listSubtypeFrom) { if (s.Parent == origin) { shapeOrigin = s; break; } } } // Find Destination Shape in Diagram foreach (EsriShape <FeatureClass> f in listFeatureClassTo) { if (f.Parent == destination) { shapeDestiantion = f; break; } } if (shapeDestiantion == null) { foreach (EsriShape <Subtype> s in listSubtypeTo) { if (s.Parent == destination) { shapeDestiantion = s; break; } } } // Skip if Origin and Destination Shapes not found if (shapeOrigin == null || shapeDestiantion == null) { continue; } EsriLine <TopologyRule> line2 = new EsriLine <TopologyRule>(topologyRule, shapeOrigin, shapeDestiantion); this.Lines.Add(this.Lines.CreateKey(), line2); } // Perform Layout this.ExecuteLayout(typeof(HierarchicalLayout), true); // Resume and Refresh Model this.SuspendEvents = false; this.Resume(); if (ModelSettings.Default.EnableUndoRedo) { this.UndoList.Resume(); } this.Refresh(); }
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { if (context == null) { return(null); } if (context.Instance == null) { return(null); } // RelationshipClass: OriginClassName, DestinationClassName // EdgeConnectivityRule: DefaultJunctionID, FromClassID, ToClassID // JunctionSubtype: ClassID // RelationshipRule: OriginClass, DestinationClass // JunctionConnectivityRule: EdgeClassID, JunctionClassID // TopologyRule: OriginClassId, DestinationClassId // NetWeightAssociation: TableName // TerrainDataSource: FeatureClassName // Get Model DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default; if (diagrammerEnvironment == null) { return(null); } SchemaModel schemaModel = diagrammerEnvironment.SchemaModel; if (schemaModel == null) { return(null); } // Get ObjectClasses List <ObjectClass> objectClasses = schemaModel.GetObjectClasses(); // Create List List <string> list = new List <string>(); if (context.PropertyDescriptor.ComponentType == typeof(RelationshipClass)) { switch (context.PropertyDescriptor.Name) { case "OriginClassName": case "DestinationClassName": foreach (ObjectClass objectClass in objectClasses) { if (objectClass.GetType() == typeof(ObjectClass) || objectClass.GetType() == typeof(FeatureClass) || objectClass.GetType() == typeof(RasterCatalog)) { list.Add(objectClass.Name); } } break; } } else if (context.PropertyDescriptor.ComponentType == typeof(EdgeConnectivityRule)) { switch (context.PropertyDescriptor.Name) { case "DefaultJunctionID": foreach (ObjectClass objectClass in objectClasses) { FeatureClass featureClass = objectClass as FeatureClass; if (featureClass == null) { continue; } switch (featureClass.FeatureType) // (objectClass.CLSID) { { case esriFeatureType.esriFTSimpleJunction: // EsriRegistry.CLASS_SIMPLEJUNCTION: list.Add(objectClass.Name); break; } } break; case "FromClassID": case "ToClassID": foreach (ObjectClass objectClass in objectClasses) { FeatureClass featureClass = objectClass as FeatureClass; if (featureClass == null) { continue; } switch (featureClass.FeatureType) // (objectClass.CLSID) { { case esriFeatureType.esriFTComplexEdge: // EsriRegistry.CLASS_COMPLEXEDGE: case esriFeatureType.esriFTSimpleEdge: // EsriRegistry.CLASS_SIMPLEEDGE: list.Add(objectClass.Name); break; } } break; } } else if (context.PropertyDescriptor.ComponentType == typeof(JunctionSubtype)) { switch (context.PropertyDescriptor.Name) { case "ClassID": foreach (ObjectClass objectClass in objectClasses) { FeatureClass featureClass = objectClass as FeatureClass; if (featureClass == null) { continue; } switch (featureClass.FeatureType) // (objectClass.CLSID) { { case esriFeatureType.esriFTSimpleJunction: // EsriRegistry.CLASS_SIMPLEJUNCTION: list.Add(objectClass.Name); break; } } break; } } else if (context.PropertyDescriptor.ComponentType == typeof(RelationshipRule)) { switch (context.PropertyDescriptor.Name) { case "OriginClass": case "DestinationClass": foreach (ObjectClass objectClass in objectClasses) { if (objectClass.GetType() == typeof(ObjectClass) || objectClass.GetType() == typeof(FeatureClass)) { list.Add(objectClass.Name); } } break; } } else if (context.PropertyDescriptor.ComponentType == typeof(JunctionConnectivityRule)) { switch (context.PropertyDescriptor.Name) { case "EdgeClassID": foreach (ObjectClass objectClass in objectClasses) { FeatureClass featureClass = objectClass as FeatureClass; if (featureClass == null) { continue; } switch (featureClass.FeatureType) // (objectClass.CLSID) { { case esriFeatureType.esriFTComplexEdge: // EsriRegistry.CLASS_COMPLEXEDGE: case esriFeatureType.esriFTSimpleEdge: // EsriRegistry.CLASS_SIMPLEEDGE: list.Add(objectClass.Name); break; } } break; case "JunctionClassID": foreach (ObjectClass objectClass in objectClasses) { FeatureClass featureClass = objectClass as FeatureClass; if (featureClass == null) { continue; } switch (featureClass.FeatureType) // (objectClass.CLSID) { { case esriFeatureType.esriFTSimpleJunction: // EsriRegistry.CLASS_SIMPLEJUNCTION: list.Add(objectClass.Name); break; } } break; } } else if (context.PropertyDescriptor.ComponentType == typeof(TopologyRule)) { switch (context.PropertyDescriptor.Name) { case "OriginClassId": case "DestinationClassId": foreach (ObjectClass objectClass in objectClasses) { if (objectClass.GetType() == typeof(FeatureClass)) { list.Add(objectClass.Name); } } break; } } else if (context.PropertyDescriptor.ComponentType == typeof(NetWeightAssociation)) { switch (context.PropertyDescriptor.Name) { case "TableName": foreach (ObjectClass objectClass in objectClasses) { FeatureClass featureClass = objectClass as FeatureClass; if (featureClass == null) { continue; } switch (featureClass.FeatureType) // (objectClass.CLSID) { { case esriFeatureType.esriFTComplexEdge: // EsriRegistry.CLASS_COMPLEXEDGE: case esriFeatureType.esriFTSimpleEdge: // EsriRegistry.CLASS_SIMPLEEDGE: case esriFeatureType.esriFTSimpleJunction: // EsriRegistry.CLASS_SIMPLEJUNCTION: list.Add(objectClass.Name); break; } } break; } } else if (context.PropertyDescriptor.ComponentType == typeof(TerrainDataSource)) { switch (context.PropertyDescriptor.Name) { case "FeatureClassName": TerrainDataSource terrainDataSource = (TerrainDataSource)context.Instance; SchemaModel model = DiagrammerEnvironment.Default.SchemaModel; if (model == null) { break; } Terrain terrain = model.FindParent(terrainDataSource); FeatureDataset featureDataset = terrain.GetParent() as FeatureDataset; if (featureDataset == null) { break; } foreach (Dataset dataset in featureDataset.GetChildren()) { if (dataset.DatasetType == esriDatasetType.esriDTFeatureClass) { list.Add(dataset.Name); } } break; } } // Sort List list.Sort(); list.Insert(0, Resources.TEXT_NONE_BR); // Return List StandardValuesCollection svc = new StandardValuesCollection(list); return(svc); }
public override void Errors(List <Error> list) { // Get Model DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default; SchemaModel schemaModel = diagrammerEnvironment.SchemaModel; // Domain Name if (string.IsNullOrEmpty(this._name)) { // Domain name cannot be null or empty list.Add(new ErrorTable(this, "Domain name cannot be empty", ErrorType.Error)); } else { // Get Validator Validator validator = WorkspaceValidator.Default.Validator; // Name must not contain invalid characters. Spaces are valid. string message = null; string name = this._name.Replace(" ", string.Empty); if (validator.ContainsInvalidCharacters(name, out message)) { list.Add(new ErrorTable(this, message, ErrorType.Error)); } // Domain name must be less thab 255 characters. if (this._name.Length > 255) { list.Add(new ErrorTable(this, "Domain name is more than 255 characters long", ErrorType.Error)); } } // Owner if (!string.IsNullOrEmpty(this._owner)) { // Owner must be less than 255 characters. if (this._owner.Length > 255) { list.Add(new ErrorTable(this, "Owner name is more than 255 characters long", ErrorType.Error)); } // Owner cannot contain spaces. if (this._owner.IndexOf(" ") != -1) { list.Add(new ErrorTable(this, "Owner name cannot contain spaces", ErrorType.Error)); } } // Description must be less than 255 characters. if (!string.IsNullOrEmpty(this._description)) { if (this._description.Length > 255) { list.Add(new ErrorTable(this, "Description is more than 255 characters long", ErrorType.Error)); } } // Is this domain unused? if (!string.IsNullOrEmpty(this._name)) { bool used = false; List <ObjectClass> objectClasses = schemaModel.GetObjectClasses(); foreach (ObjectClass objectClass in objectClasses) { List <Field> fields = objectClass.GetFields(); foreach (Field field in fields) { if (field.Domain == this._name) { used = true; break; } } List <Subtype> subtypes = objectClass.GetSubtypes(); foreach (Subtype subtype in subtypes) { List <SubtypeField> subtypeFields = subtype.GetSubtypeFields(); foreach (SubtypeField subtypeField in subtypeFields) { if (subtypeField.DomainName == this._name) { used = true; break; } } if (used) { break; } } } if (!used) { string message = string.Format("Domain [{0}] is not used by any Table or FeatureClass", this._name); list.Add(new ErrorTable(this, message, ErrorType.Warning)); } } }
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { if (context == null) { return(null); } if (context.Instance == null) { return(null); } if (value.GetType() == typeof(string)) { string text = Convert.ToString(value); if (context.PropertyDescriptor.ComponentType == typeof(RelationshipClass)) { switch (context.PropertyDescriptor.Name) { case "OriginClassName": case "DestinationClassName": if (text == string.Empty || text == Resources.TEXT_NONE_BR) { return(string.Empty); } return(text); } } else if (context.PropertyDescriptor.ComponentType == typeof(EdgeConnectivityRule)) { switch (context.PropertyDescriptor.Name) { case "DefaultJunctionID": case "FromClassID": case "ToClassID": if (text == string.Empty || text == Resources.TEXT_NONE_BR) { return(-1); } DiagrammerEnvironment de = DiagrammerEnvironment.Default; SchemaModel model = de.SchemaModel; ObjectClass objectClass = model.FindObjectClass(text); if (objectClass == null) { return(-1); } return(objectClass.DSID); } } else if (context.PropertyDescriptor.ComponentType == typeof(JunctionSubtype)) { switch (context.PropertyDescriptor.Name) { case "ClassID": if (text == string.Empty || text == Resources.TEXT_NONE_BR) { return(-1); } DiagrammerEnvironment de = DiagrammerEnvironment.Default; SchemaModel model = de.SchemaModel; ObjectClass objectClass = model.FindObjectClass(text); if (objectClass == null) { return(-1); } return(objectClass.DSID); } } else if (context.PropertyDescriptor.ComponentType == typeof(RelationshipRule)) { switch (context.PropertyDescriptor.Name) { case "OriginClass": case "DestinationClass": if (text == string.Empty || text == Resources.TEXT_NONE_BR) { return(-1); } DiagrammerEnvironment de = DiagrammerEnvironment.Default; SchemaModel model = de.SchemaModel; ObjectClass objectClass = model.FindObjectClass(text); if (objectClass == null) { return(-1); } return(objectClass.DSID); } } else if (context.PropertyDescriptor.ComponentType == typeof(JunctionConnectivityRule)) { switch (context.PropertyDescriptor.Name) { case "EdgeClassID": case "JunctionClassID": if (text == string.Empty || text == Resources.TEXT_NONE_BR) { return(-1); } DiagrammerEnvironment de = DiagrammerEnvironment.Default; SchemaModel model = de.SchemaModel; ObjectClass objectClass = model.FindObjectClass(text); if (objectClass == null) { return(-1); } return(objectClass.DSID); } } else if (context.PropertyDescriptor.ComponentType == typeof(TopologyRule)) { switch (context.PropertyDescriptor.Name) { case "OriginClassId": case "DestinationClassId": if (text == string.Empty || text == Resources.TEXT_NONE_BR) { return(-1); } DiagrammerEnvironment de = DiagrammerEnvironment.Default; SchemaModel model = de.SchemaModel; ObjectClass objectClass = model.FindObjectClass(text); if (objectClass == null) { return(-1); } return(objectClass.DSID); } } else if (context.PropertyDescriptor.ComponentType == typeof(NetWeightAssociation)) { switch (context.PropertyDescriptor.Name) { case "TableName": if (text == string.Empty || text == Resources.TEXT_NONE_BR) { return(string.Empty); } return(text); } } else if (context.PropertyDescriptor.ComponentType == typeof(TerrainDataSource)) { switch (context.PropertyDescriptor.Name) { case "FeatureClassName": if (text == string.Empty || text == Resources.TEXT_NONE_BR) { return(string.Empty); } return(text); } } } return(base.ConvertFrom(context, culture, value)); }
private void Model_ElementInvalid(object sender, ElementEventArgs e) { // Exit if GeometricNetwork Does not Exist if (this._topology == null) { return; } // Get Element Element element = e.Value; if (element == null) { return; } EsriLine <TopologyControllerMembership> line = element as EsriLine <TopologyControllerMembership>; if (line == null) { return; } // Get Controller TopologyControllerMembership controller = line.Parent; // Suspend Rule Events controller.Suspend(); // Get Start and End Elements Element elementStart = line.Start.Shape; Element elementEnd = line.End.Shape; // Update GeometricNetwork Name Property if (elementStart == null) { controller.TopologyName = string.Empty; } else if (elementStart is EsriShape <Topology> ) { EsriShape <Topology> shape = (EsriShape <Topology>)elementStart; Topology topology = shape.Parent; controller.TopologyName = topology.Name; } // DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default; SchemaModel schemaModel = diagrammerEnvironment.SchemaModel; ObjectClass objectClass = schemaModel.FindParent(controller); if (objectClass != null) { objectClass.ControllerMemberships.Remove(controller); } if (elementEnd == null) { } else if (elementEnd is EsriShape <FeatureClass> ) { EsriShape <FeatureClass> es = (EsriShape <FeatureClass>)elementEnd; FeatureClass featureClass = es.Parent; featureClass.ControllerMemberships.Add(controller); } // Resume Controller Events controller.Resume(); }
protected override void WriteInnerXml(XmlWriter writer) { // Write Base Inner Xml base.WriteInnerXml(writer); // Get Model SchemaModel model = (SchemaModel)base.Container; // <HasOID></HasOID> bool hasOID = !(string.IsNullOrEmpty(this._oidFieldName)); writer.WriteStartElement("HasOID"); writer.WriteValue(hasOID); writer.WriteEndElement(); // <OIDFieldName></OIDFieldName> writer.WriteStartElement("OIDFieldName"); if (hasOID) { writer.WriteValue(this._oidFieldName); } writer.WriteEndElement(); // <Fields> TableGroup tableGroupField = (TableGroup)this.Groups[0]; writer.WriteStartElement("Fields"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:Fields"); // <FieldArray> writer.WriteStartElement("FieldArray"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:ArrayOfField"); // <Field></Field> foreach (Field field in tableGroupField.Rows) { field.WriteXml(writer); } // </FieldArray> writer.WriteEndElement(); // </Fields> writer.WriteEndElement(); // <Indexes> TableGroup tableGroupIndex = (TableGroup)this.Groups[1]; writer.WriteStartElement("Indexes"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:Indexes"); // <IndexArray> writer.WriteStartElement("IndexArray"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:ArrayOfIndex"); // <Index> foreach (Index index in tableGroupIndex.Groups) { index.WriteXml(writer); } // </IndexArray> writer.WriteEndElement(); // </Indexes> writer.WriteEndElement(); // <CLSID></CLSID> writer.WriteStartElement("CLSID"); writer.WriteValue(this._clsid); writer.WriteEndElement(); // <EXTCLSID></EXTCLSID> writer.WriteStartElement("EXTCLSID"); if (!string.IsNullOrEmpty(this._extClsid)) { writer.WriteValue(this._extClsid); } writer.WriteEndElement(); // <RelationshipClassNames> writer.WriteStartElement("RelationshipClassNames"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:Names"); // <Name></Name> List <Dataset> datasets = model.GetDatasets(new Type[] { typeof(RelationshipClass) }); foreach (RelationshipClass relationshipClass in datasets) { if (relationshipClass.OriginClassName == this.Name || relationshipClass.DestinationClassName == this.Name) { // <Name></Name> writer.WriteStartElement("Name"); writer.WriteValue(relationshipClass.Name); writer.WriteEndElement(); } } // </RelationshipClassNames> writer.WriteEndElement(); // <AliasName></AliasName> writer.WriteStartElement("AliasName"); writer.WriteValue(this._aliasName); writer.WriteEndElement(); // <ModelName></ModelName> writer.WriteStartElement("ModelName"); if (!string.IsNullOrEmpty(this._modelName)) { writer.WriteValue(this._modelName); } writer.WriteEndElement(); // <HasGlobalID></HasGlobalID> bool hasGlobalID = !(string.IsNullOrEmpty(this._globalIDFieldName)); writer.WriteStartElement("HasGlobalID"); writer.WriteValue(hasGlobalID); writer.WriteEndElement(); // <GlobalIDFieldName></GlobalIDFieldName> writer.WriteStartElement("GlobalIDFieldName"); if (hasGlobalID) { writer.WriteValue(this._globalIDFieldName); } writer.WriteEndElement(); // <RasterFieldName></RasterFieldName> writer.WriteStartElement("RasterFieldName"); if (!string.IsNullOrEmpty(this._rasterFieldName)) { writer.WriteValue(this._rasterFieldName); } writer.WriteEndElement(); // <ExtensionProperties> writer.WriteStartElement("ExtensionProperties"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:PropertySet"); // <PropertyArray> writer.WriteStartElement("PropertyArray"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:ArrayOfPropertySetProperty"); foreach (Property property in this._extensionProperties) { // <PropertySetProperty></PropertySetProperty> property.WriteXml(writer); } // </PropertyArray> writer.WriteEndElement(); // </ExtensionProperties> writer.WriteEndElement(); // Check if there are any subtypes List <Subtype> subtypes = this.GetSubtypes(); // Validate Subtypes int defaultSubtypeCode = -1; foreach (Subtype subtype in subtypes) { if (subtype.Default) { defaultSubtypeCode = subtype.SubtypeCode; } } // Write Subtypes if (subtypes.Count > 0) { // <SubtypeFieldName> writer.WriteStartElement("SubtypeFieldName"); writer.WriteValue(this._subtypeFieldName); writer.WriteEndElement(); // <DefaultSubtypeCode> writer.WriteStartElement("DefaultSubtypeCode"); writer.WriteValue(defaultSubtypeCode); writer.WriteEndElement(); // <Subtypes> writer.WriteStartElement("Subtypes"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:ArrayOfSubtype"); // <Subtype></Subtype> foreach (Subtype subtype in subtypes) { subtype.WriteXml(writer); } // </Subtypes> writer.WriteEndElement(); } // <ControllerMemberships> writer.WriteStartElement("ControllerMemberships"); writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:ArrayOfControllerMembership"); // <ControllerMembership></ControllerMembership> foreach (ControllerMembership controllerMembership in this._controllerMemberships) { controllerMembership.WriteXml(writer); } // </ControllerMemberships> writer.WriteEndElement(); }
// // PROTECTED METHODS // protected override void WriteInnerXml(XmlWriter writer) { // base.WriteInnerXml(writer); // Get Model SchemaModel model = DiagrammerEnvironment.Default.SchemaModel; // <Name></Name> writer.WriteStartElement("Name"); writer.WriteValue(this._name); writer.WriteEndElement(); // <Type></Type> writer.WriteStartElement("Type"); writer.WriteValue(this._fieldType.ToString()); writer.WriteEndElement(); // <IsNullable></IsNullable> writer.WriteStartElement("IsNullable"); writer.WriteValue(this._isNullable); writer.WriteEndElement(); // <Length></Length> writer.WriteStartElement("Length"); writer.WriteValue(this._length); writer.WriteEndElement(); // <Precision></Precision> writer.WriteStartElement("Precision"); writer.WriteValue(this._precision); writer.WriteEndElement(); // <Scale></Scale> writer.WriteStartElement("Scale"); writer.WriteValue(this._scale); writer.WriteEndElement(); // <Required></Required> if (this._required) { writer.WriteStartElement("Required"); writer.WriteValue(this._required); writer.WriteEndElement(); } // <Editable></Editable> if (!this._editable) { writer.WriteStartElement("Editable"); writer.WriteValue(this._editable); writer.WriteEndElement(); } // <DomainFixed></DomainFixed> if (this._domainFixed) { writer.WriteStartElement("DomainFixed"); writer.WriteValue(this._domainFixed); writer.WriteEndElement(); } // <GeometryDef></GeometryDef> if (this._geometryDef != null) { this._geometryDef.WriteXml(writer); } // <AliasName></AliasName> if (!string.IsNullOrEmpty(this._aliasName)) { writer.WriteStartElement("AliasName"); writer.WriteValue(this._aliasName); writer.WriteEndElement(); } // <ModelName></ModelName> if (!string.IsNullOrEmpty(this._modelName)) { writer.WriteStartElement("ModelName"); writer.WriteValue(this._modelName); writer.WriteEndElement(); } // <DefaultValue></DefaultValue> if (!string.IsNullOrEmpty(this._defaultValue)) { writer.WriteStartElement("DefaultValue"); switch (this._fieldType) { case esriFieldType.esriFieldTypeSmallInteger: writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "xs:short"); break; case esriFieldType.esriFieldTypeInteger: writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "xs:int"); break; case esriFieldType.esriFieldTypeSingle: writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "xs:float"); break; case esriFieldType.esriFieldTypeDouble: writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "xs:double"); break; case esriFieldType.esriFieldTypeDate: writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "xs:dateTime"); break; case esriFieldType.esriFieldTypeString: writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "xs:string"); break; default: break; } writer.WriteValue(this._defaultValue); writer.WriteEndElement(); } // <Domain></Domain> if (!string.IsNullOrEmpty(this._domain)) { //SchemaModel model = (SchemaModel)this.Table.Container; Domain domain = model.FindDomain(this._domain); if (domain != null) { domain.WriteXml(writer); } } // <RasterDef></RasterDef> if (this._rasterDef != null) { this._rasterDef.WriteXml(writer); } }
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; } } }