private void Model_ElementInvalid(object sender, ElementEventArgs e)
{
// Check Relationship
if (this._relationshipClass == null)
{
return;
}
// Get Element
Element element = e.Value;
if (element == null)
{
return;
}
EsriLine <RelationshipRule> line = element as EsriLine <RelationshipRule>;
if (line == null)
{
return;
}
// Get Rule
RelationshipRule rule = line.Parent;
// Suspend Rule Events
rule.Suspend();
//
Element elementStart = line.Start.Shape;
Element elementEnd = line.End.Shape;
// Update Origin Class/Subtype
if (elementStart == null)
{
rule.OriginClass = -1;
rule.OriginSubtype = -1;
}
else if (elementStart is EsriShape <ObjectClass> )
{
EsriShape <ObjectClass> shape = (EsriShape <ObjectClass>)elementStart;
ObjectClass objectClass = shape.Parent;
rule.OriginClass = objectClass.DSID;
rule.OriginSubtype = 0;
}
else if (elementStart is EsriShape <FeatureClass> )
{
EsriShape <FeatureClass> shape = (EsriShape <FeatureClass>)elementStart;
FeatureClass featureClass = shape.Parent;
rule.OriginClass = featureClass.DSID;
rule.OriginSubtype = 0;
}
else if (elementStart is EsriShape <Subtype> )
{
EsriShape <Subtype> shape = (EsriShape <Subtype>)elementStart;
Subtype subtype = shape.Parent;
ObjectClass objectClass = subtype.GetParent();
if (objectClass != null)
{
rule.OriginClass = objectClass.DSID;
rule.OriginSubtype = subtype.SubtypeCode;
}
}
// Update Destination Class/Subtype
if (elementEnd == null)
{
rule.DestinationClass = -1;
rule.DestinationSubtype = -1;
}
else if (elementEnd is EsriShape <ObjectClass> )
{
EsriShape <ObjectClass> shape = (EsriShape <ObjectClass>)elementEnd;
ObjectClass objectClass = shape.Parent;
rule.DestinationClass = objectClass.DSID;
rule.DestinationSubtype = 0;
}
else if (elementEnd is EsriShape <FeatureClass> )
{
EsriShape <FeatureClass> shape = (EsriShape <FeatureClass>)elementEnd;
FeatureClass featureClass = shape.Parent;
rule.DestinationClass = featureClass.DSID;
rule.DestinationSubtype = 0;
}
else if (elementEnd is EsriShape <Subtype> )
{
EsriShape <Subtype> shape = (EsriShape <Subtype>)elementEnd;
Subtype subtype = shape.Parent;
ObjectClass objectClass = subtype.GetParent();
if (objectClass != null)
{
rule.DestinationClass = objectClass.DSID;
rule.DestinationSubtype = subtype.SubtypeCode;
}
}
// Resume Rule Events
rule.Resume();
}
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
if (context == null)
{
return(null);
}
if (context.Instance == null)
{
return(null);
}
// FeatureClass::ShapeFieldName, AreaFieldName, LengthFieldName, ShapeFieldName
// GeometricNetworkControllerMembership::EnabledFieldName, AncillaryRoleFieldName
// IndexField::Name
// ObjectClass::OIDFieldName, GlobalIDFieldName, RasterFieldName, SubtypeFieldName, OIDFieldName, GlobalIDFieldName
// RelationshipClass::OriginPrimary, OriginForeign, DestinationPrimary, DestinationForeign
// SubtypeField::FieldName
// NetWeightAssociation::FieldName
// TerrainDataSource::HeightField, TagValueField
// Create List
List <string> list = new List <string>();
DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default;
SchemaModel schemaModel = diagrammerEnvironment.SchemaModel;
if (context.PropertyDescriptor.ComponentType == typeof(IndexField))
{
IndexField indexField = (IndexField)context.Instance;
ObjectClass objectClass = (ObjectClass)indexField.Table;
foreach (Field field in objectClass.GetFields())
{
list.Add(field.Name);
}
}
else if (context.PropertyDescriptor.ComponentType == typeof(GeometricNetworkControllerMembership))
{
GeometricNetworkControllerMembership geometricNetworkControllerMembership = (GeometricNetworkControllerMembership)context.Instance;
ObjectClass objectClass = schemaModel.FindParent(geometricNetworkControllerMembership);
foreach (Field field in objectClass.GetFields())
{
list.Add(field.Name);
}
}
else if (context.PropertyDescriptor.ComponentType == typeof(SubtypeField))
{
SubtypeField subtypeField = (SubtypeField)context.Instance;
Subtype subtype = (Subtype)subtypeField.Table;
ObjectClass objectClass = subtype.GetParent();
foreach (Field field in objectClass.GetFields())
{
list.Add(field.Name);
}
}
else if (context.PropertyDescriptor.ComponentType == typeof(ObjectClass))
{
ObjectClass objectClass = (ObjectClass)context.Instance;
foreach (Field field in objectClass.GetFields())
{
list.Add(field.Name);
}
}
else if (context.PropertyDescriptor.ComponentType == typeof(RelationshipClass))
{
RelationshipClass relationshipClass = (RelationshipClass)context.Instance;
if (relationshipClass.IsAttributed)
{
switch (context.PropertyDescriptor.Name)
{
case "OIDFieldName":
case "GlobalIDFieldName":
case "RasterFieldName":
case "SubtypeFieldName":
foreach (Field field in relationshipClass.GetFields())
{
list.Add(field.Name);
}
break;
case "OriginPrimary":
ObjectClass objectClass1 = schemaModel.FindObjectClass(relationshipClass.OriginClassName);
foreach (Field field in objectClass1.GetFields())
{
list.Add(field.Name);
}
break;
case "OriginForeign":
case "DestinationForeign":
foreach (Field field in relationshipClass.GetFields())
{
list.Add(field.Name);
}
break;
case "DestinationPrimary":
ObjectClass objectClass2 = schemaModel.FindObjectClass(relationshipClass.DestinationClassName);
foreach (Field field in objectClass2.GetFields())
{
list.Add(field.Name);
}
break;
}
}
else
{
switch (context.PropertyDescriptor.Name)
{
case "OIDFieldName":
case "GlobalIDFieldName":
case "RasterFieldName":
case "SubtypeFieldName":
foreach (Field field in relationshipClass.GetFields())
{
list.Add(field.Name);
}
break;
case "OriginPrimary":
ObjectClass objectClass1 = schemaModel.FindObjectClass(relationshipClass.OriginClassName);
foreach (Field field in objectClass1.GetFields())
{
list.Add(field.Name);
}
break;
case "OriginForeign":
ObjectClass objectClass2 = schemaModel.FindObjectClass(relationshipClass.DestinationClassName);
foreach (Field field in objectClass2.GetFields())
{
list.Add(field.Name);
}
break;
case "DestinationPrimary":
case "DestinationForeign":
break;
}
}
}
else if (
context.PropertyDescriptor.ComponentType == typeof(FeatureClass) ||
context.PropertyDescriptor.ComponentType == typeof(RasterCatalog))
{
FeatureClass featureClass = (FeatureClass)context.Instance;
foreach (Field field in featureClass.GetFields())
{
list.Add(field.Name);
}
}
else if (context.PropertyDescriptor.ComponentType == typeof(NetWeightAssociation))
{
NetWeightAssociation netWeightAssociation = (NetWeightAssociation)context.Instance;
if (netWeightAssociation != null)
{
if (!string.IsNullOrEmpty(netWeightAssociation.TableName))
{
ObjectClass objectClass = schemaModel.FindObjectClass(netWeightAssociation.TableName);
if (objectClass != null)
{
foreach (Field field in objectClass.GetFields())
{
list.Add(field.Name);
}
}
}
}
}
else if (context.PropertyDescriptor.ComponentType == typeof(TerrainDataSource))
{
TerrainDataSource terrainDataSource = (TerrainDataSource)context.Instance;
if (terrainDataSource != null)
{
if (!string.IsNullOrEmpty(terrainDataSource.FeatureClassName))
{
ObjectClass objectClass = schemaModel.FindObjectClass(terrainDataSource.FeatureClassName);
if (objectClass != null)
{
foreach (Field field in objectClass.GetFields())
{
list.Add(field.Name);
}
}
}
}
}
// Sort field name list and insert "None" item
list.Sort();
list.Insert(0, Resources.TEXT_NONE_BR);
// Return sort field name list
StandardValuesCollection svc = new StandardValuesCollection(list);
return(svc);
}
public override void Errors(List <Error> list)
{
// Field Name Null or Empty
if (string.IsNullOrEmpty(this._fieldName))
{
list.Add(new ErrorTableRow(this, "Subtype Field names cannot be empty", ErrorType.Error));
}
// Get DiagrammerEnvironment Singleton
DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default;
SchemaModel schemaModel = diagrammerEnvironment.SchemaModel;
// Get Subtype
Subtype subtype = (Subtype)this.Table;
// Get ObjectClass
ObjectClass objectClass = subtype.GetParent();
if (objectClass == null)
{
// This error is handled by the Subtype class
return;
}
// Get Field
Field field = objectClass.FindField(this._fieldName);
if (field == null)
{
// Field is missing in parent ObjectClass
string message = string.Format("The subtype field [{0}] does not exist in the parent objectclass", this._fieldName);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
return;
}
// Warning if parent default value and domain are identical
if (this._defaultValue == field.DefaultValue &&
this._domainName == field.Domain)
{
string message = string.Format("The default values and domain for the subtype field [{0}] are identical to those in the parent objectclass", this._fieldName);
list.Add(new ErrorTableRow(this, message, ErrorType.Warning));
}
// Field can only be small int, long in, single, double, text, date, guid
switch (field.FieldType)
{
case esriFieldType.esriFieldTypeDate:
case esriFieldType.esriFieldTypeDouble:
case esriFieldType.esriFieldTypeGUID:
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeSmallInteger:
case esriFieldType.esriFieldTypeString:
// OK
break;
case esriFieldType.esriFieldTypeRaster:
case esriFieldType.esriFieldTypeBlob:
case esriFieldType.esriFieldTypeGeometry:
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeGlobalID:
case esriFieldType.esriFieldTypeXML:
string message = string.Format("The subtype field [{0}] must use a field of type Date, Double, Guid, Integer, Single, SmallInteger or String", this._fieldName);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
break;
}
// Find Domain
if (!string.IsNullOrEmpty(this._domainName))
{
// Get Domain
Domain domain = schemaModel.FindDomain(this._domainName);
if (domain == null)
{
// Domain does not exit
string message = string.Format("The domain [{0}] for field [{1}] does not exist", this._domainName, field.Name);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
}
else
{
// Compare domain and field types
if (field.FieldType != domain.FieldType)
{
string message = string.Format("The field [{0}] and assigned domain [{1}] do not have matching field types.", field.Name, this._domainName);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
}
// Check Default Value (
if (!string.IsNullOrEmpty(this._defaultValue))
{
string message = null;
if (!domain.IsValid(this._defaultValue, out message))
{
list.Add(new ErrorTableRow(this, message, ErrorType.Warning));
}
}
// Check if a domain value is too long for the text field
if (field.FieldType == esriFieldType.esriFieldTypeString &&
domain.FieldType == esriFieldType.esriFieldTypeString &&
domain.GetType() == typeof(DomainCodedValue))
{
DomainCodedValue domain2 = (DomainCodedValue)domain;
foreach (DomainCodedValueRow x in domain2.CodedValues)
{
if (string.IsNullOrEmpty(x.Code))
{
continue;
}
if (x.Code.Length > field.Length)
{
string message = string.Format("The domain [{0}] has a value [{1}] that is too long for the field [{2}]", this._domainName, x, this._fieldName);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
}
}
}
}
}
// Check validity of default value against field type
if (!string.IsNullOrEmpty(this._defaultValue))
{
string message;
if (!GeodatabaseUtility.IsValidateValue(field.FieldType, this._defaultValue, out message))
{
string message2 = string.Format("Default value [{0}] {1}", this._defaultValue, message);
list.Add(new ErrorTableRow(this, message2, ErrorType.Error));
}
}
//
if (!string.IsNullOrEmpty(this._defaultValue))
{
if (!string.IsNullOrEmpty(this._domainName))
{
if (!string.IsNullOrEmpty(field.Domain))
{
if (this._domainName != field.Domain)
{
Domain domain2 = schemaModel.FindDomain(field.Domain);
string message = null;
if (!domain2.IsValid(this._defaultValue, out message))
{
string message2 = string.Format("NIM013605: Field [{0}] - {1}", this._fieldName, message);
list.Add(new ErrorTableRow(this, message2, ErrorType.Error));
}
}
}
}
}
}
protected override void WriteInnerXml(XmlWriter writer)
{
base.WriteInnerXml(writer);
// Get Model
Subtype subtype = (Subtype)this.Table;
ObjectClass objectClass = subtype.GetParent();
// <FieldName></FieldName>
writer.WriteStartElement("FieldName");
writer.WriteValue(this._fieldName);
writer.WriteEndElement();
if (!string.IsNullOrEmpty(this._domainName))
{
// <DomainName></DomainName>
writer.WriteStartElement("DomainName");
writer.WriteValue(this._domainName);
writer.WriteEndElement();
}
// Get Field
Field field = objectClass.FindField(this._fieldName);
//
if (!string.IsNullOrEmpty(this._defaultValue))
{
// Get correct data type value
string dataType = string.Empty;
switch (field.FieldType)
{
case esriFieldType.esriFieldTypeSmallInteger:
dataType = "xs:short";
break;
case esriFieldType.esriFieldTypeInteger:
dataType = "xs:int";
break;
case esriFieldType.esriFieldTypeSingle:
dataType = "xs:float";
break;
case esriFieldType.esriFieldTypeDouble:
dataType = "xs:double";
break;
case esriFieldType.esriFieldTypeString:
dataType = "xs:string";
break;
case esriFieldType.esriFieldTypeDate:
dataType = "xs:dateTime";
break;
}
// <DefaultValue></DefaultValue>
writer.WriteStartElement("DefaultValue");
writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, dataType);
writer.WriteValue(this._defaultValue);
writer.WriteEndElement();
}
}
private void Model_ElementInvalid(object sender, ElementEventArgs e)
{
// Exit if Topology Does not Exist
if (this._topology == null)
{
return;
}
// Get Element
Element element = e.Value;
if (element == null)
{
return;
}
EsriLine <TopologyRule> line = element as EsriLine <TopologyRule>;
if (line == null)
{
return;
}
// Get TopologyRule
TopologyRule rule = line.Parent;
// Suspend Rule Events
rule.Suspend();
// Get Start and End Elements
Element elementStart = line.Start.Shape;
Element elementEnd = line.End.Shape;
// Update Start Class/Subtype
if (elementStart == null)
{
rule.AllOriginSubtypes = false;
rule.OriginClassId = -1;
rule.OriginSubtype = -1;
}
else if (elementStart is EsriShape <FeatureClass> )
{
EsriShape <FeatureClass> shape = (EsriShape <FeatureClass>)elementStart;
ObjectClass objectClass = shape.Parent;
rule.AllOriginSubtypes = true;
rule.OriginClassId = objectClass.DSID;
rule.OriginSubtype = 0;
}
else if (elementStart is EsriShape <Subtype> )
{
EsriShape <Subtype> shape = (EsriShape <Subtype>)elementStart;
Subtype subtype = shape.Parent;
ObjectClass objectClass = subtype.GetParent();
rule.AllOriginSubtypes = false;
if (objectClass == null)
{
rule.OriginClassId = -1;
rule.OriginSubtype = -1;
}
else
{
rule.OriginClassId = objectClass.DSID;
rule.OriginSubtype = subtype.SubtypeCode;
}
}
// Update End Class/Subtype
if (elementEnd == null)
{
rule.AllDestinationSubtypes = false;
rule.DestinationClassId = -1;
rule.DestinationSubtype = -1;
}
else if (elementEnd is EsriShape <FeatureClass> )
{
EsriShape <FeatureClass> shape = (EsriShape <FeatureClass>)elementEnd;
ObjectClass objectClass = shape.Parent;
rule.AllDestinationSubtypes = true;
rule.DestinationClassId = objectClass.DSID;
rule.DestinationSubtype = 0;
}
else if (elementEnd is EsriShape <Subtype> )
{
EsriShape <Subtype> shape = (EsriShape <Subtype>)elementEnd;
Subtype subtype = shape.Parent;
ObjectClass objectClass = subtype.GetParent();
rule.AllDestinationSubtypes = false;
if (objectClass == null)
{
rule.DestinationClassId = -1;
rule.DestinationSubtype = -1;
}
else
{
rule.DestinationClassId = objectClass.DSID;
rule.DestinationSubtype = subtype.SubtypeCode;
}
}
// Resume Rule Events
rule.Resume();
}
private void Model_ElementInvalid(object sender, ElementEventArgs e)
{
// Exit if GeometricNetwork Does not Exist
if (this._geometricNetwork == null)
{
return;
}
// Get Element
Element element = e.Value;
if (element == null)
{
return;
}
EsriLine <JunctionConnectivityRule> line = element as EsriLine <JunctionConnectivityRule>;
if (line == null)
{
return;
}
// Get EdgeConnectivityRule
JunctionConnectivityRule rule = line.Parent;
// Suspend Rule Events
rule.Suspend();
// Get Start and End Elements
Element elementStart = line.Start.Shape;
Element elementEnd = line.End.Shape;
// Update Start Class/Subtype
if (elementStart == null)
{
rule.EdgeClassID = -1;
rule.EdgeSubtypeCode = -1;
}
else if (elementStart is EsriShape <FeatureClass> )
{
EsriShape <FeatureClass> shape = (EsriShape <FeatureClass>)elementStart;
ObjectClass objectClass = shape.Parent;
rule.EdgeClassID = objectClass.DSID;
rule.EdgeSubtypeCode = 0;
}
else if (elementStart is EsriShape <Subtype> )
{
EsriShape <Subtype> shape = (EsriShape <Subtype>)elementStart;
Subtype subtype = shape.Parent;
ObjectClass objectClass = subtype.GetParent();
if (objectClass == null)
{
rule.EdgeClassID = -1;
rule.EdgeSubtypeCode = -1;
}
else
{
rule.EdgeClassID = objectClass.DSID;
rule.EdgeSubtypeCode = subtype.SubtypeCode;
}
}
// Update End Class/Subtype
if (elementEnd == null)
{
rule.JunctionClassID = -1;
rule.SubtypeCode = -1;
}
else if (elementEnd is EsriShape <FeatureClass> )
{
EsriShape <FeatureClass> shape = (EsriShape <FeatureClass>)elementEnd;
ObjectClass objectClass = shape.Parent;
rule.JunctionClassID = objectClass.DSID;
rule.SubtypeCode = 0;
}
else if (elementEnd is EsriShape <Subtype> )
{
EsriShape <Subtype> shape = (EsriShape <Subtype>)elementEnd;
Subtype subtype = shape.Parent;
ObjectClass objectClass = subtype.GetParent();
if (objectClass == null)
{
rule.JunctionClassID = -1;
rule.SubtypeCode = -1;
}
else
{
rule.JunctionClassID = objectClass.DSID;
rule.SubtypeCode = subtype.SubtypeCode;
}
}
// Resume Rule Events
rule.Resume();
}