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;
}
}
}