//
// PUBLIC METHODS
//
/// <summary>
/// Validates a table name
/// </summary>
/// <param name="name">The table name to validate</param>
/// <param name="message">If table name fails then this variable will contain a description</param>
/// <returns>True if passed. False if failed.</returns>
public bool ValidateTableName(string name, out string message)
{
// Check Arguments
if (string.IsNullOrEmpty(name))
{
throw new NullReferenceException("<name> argument cannot be null");
}
// Get Table Name
string tableName = GeodatabaseUtility.GetTableName(name);
// Validate Table Name
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.ValidateWorkspace = this._workspace;
string newName = null;
int error = fieldChecker.ValidateTableName(tableName, out newName);
// Create Message
switch (error)
{
case 0:
message = null;
break;
case 1:
message = string.Format("Table name [{0}] contains a reserved word.", name);
break;
case 2:
message = string.Format("Table name [{0}] contains an invalid character.", name);
break;
case 4:
message = string.Format("Table name [{0}] has invalid starting character.", name);
break;
default:
message = string.Format("Table name [{0}] is invalid.", name);
break;
}
// Append Recommended Name
switch (error)
{
case 0:
return(true);
default:
if (!(string.IsNullOrEmpty(newName)))
{
if (newName != name)
{
message += string.Format(" Try [{0}].", newName);
}
}
return(false);
}
}
public static string ProcessDataObject(DragEventArgs e)
{
// If the dropped object is from ArcCatalog then export the geodatabase
// to XML and return pathname.
if (e.Data.GetDataPresent("ESRI Names"))
{
return(GeodatabaseUtility.ExportXml(e));
}
// If a use dropped one or more files then get first file and verify that it
// has a "xml" or "diagram" extension.
if (e.Data.GetDataPresent(DataFormats.FileDrop))
{
object drop = e.Data.GetData(DataFormats.FileDrop);
if (drop == null)
{
return(null);
}
string[] files = drop as string[];
if (files == null)
{
return(null);
}
if (files.Length != 1)
{
return(null);
}
string file = files[0];
string extension = System.IO.Path.GetExtension(file);
switch (extension.ToUpper())
{
case ".XML":
case ".DIAGRAM":
return(file);
default:
return(null);
}
}
// Invalid DataObject. Return Null.
return(null);
}
public static string ExportXml(DragEventArgs e)
{
// Get dropped object
if (!e.Data.GetDataPresent("ESRI Names"))
{
return(null);
}
object drop = e.Data.GetData("ESRI Names");
// Convert to byte array
MemoryStream memoryStream = (MemoryStream)drop;
byte[] bytes = memoryStream.ToArray();
object byteArray = (object)bytes;
// Get First WorkpaceName
INameFactory nameFactory = new NameFactoryClass();
IEnumName enumName = nameFactory.UnpackageNames(ref byteArray);
IName name = enumName.Next();
IWorkspaceName workspaceName = name as IWorkspaceName;
if (workspaceName != null)
{
return(GeodatabaseUtility.ExportWorkspaceXml(workspaceName));
}
;
MessageBox.Show(
Resources.TEXT_DROPPED_OBJECT_NOT_VALID_GEODATABASE,
Resources.TEXT_APPLICATION,
MessageBoxButtons.OK,
MessageBoxIcon.Error,
MessageBoxDefaultButton.Button1,
MessageBoxOptions.DefaultDesktopOnly);
return(null);
}
private void AddDataset(XmlWriter writer, IDatasetName datasetName)
{
// Check Parameters
if (writer == null)
{
return;
}
if (datasetName == null)
{
return;
}
// Open Dataset
IName name = datasetName as IName;
if (name == null)
{
return;
}
object o = null;
try {
o = name.Open();
}
catch { }
if (o == null)
{
return;
}
IDataset dataset = o as IDataset;
if (dataset == null)
{
return;
}
IFeatureClass featureClass = dataset as IFeatureClass;
// <Dataset>
writer.WriteStartElement("Dataset");
// <Dataset><Name>
writer.WriteStartElement("Name");
writer.WriteValue(dataset.Name);
writer.WriteEndElement();
// <Dataset><Type>
string type = string.Empty;
switch (dataset.Type)
{
case esriDatasetType.esriDTFeatureClass:
if (featureClass == null)
{
type += "Unknown";
break;
}
switch (featureClass.FeatureType)
{
case esriFeatureType.esriFTAnnotation:
case esriFeatureType.esriFTDimension:
case esriFeatureType.esriFTSimple:
type += GeodatabaseUtility.GetDescription(esriDatasetType.esriDTFeatureClass);
break;
default:
type += GeodatabaseUtility.GetDescription(featureClass.FeatureType);
break;
}
break;
default:
type += GeodatabaseUtility.GetDescription(dataset.Type);
break;
}
writer.WriteStartElement("Type");
writer.WriteValue(type);
writer.WriteEndElement();
// <Dataset><Geometry>
string geometry = "-";
if (featureClass != null)
{
switch (featureClass.FeatureType)
{
case esriFeatureType.esriFTAnnotation:
case esriFeatureType.esriFTDimension:
geometry = GeodatabaseUtility.GetDescription(featureClass.FeatureType);
break;
default:
geometry = GeodatabaseUtility.GetDescription(featureClass.ShapeType);
break;
}
}
writer.WriteStartElement("Geometry");
writer.WriteValue(geometry);
writer.WriteEndElement();
//if (dataset is IFeatureClass) {
// IFeatureClass featureClass = (IFeatureClass)dataset;
// // <Dataset><FeatureType>
// writer.WriteStartElement("FeatureType");
// writer.WriteValue(GeodatabaseUtility.GetDescription(featureClass.FeatureType));
// writer.WriteEndElement();
// // Add ...<Dataset><ShapeType>
// switch (featureClass.FeatureType) {
// case esriFeatureType.esriFTAnnotation:
// case esriFeatureType.esriFTDimension:
// break;
// default:
// writer.WriteStartElement("ShapeType");
// writer.WriteValue(GeodatabaseUtility.GetDescription(featureClass.ShapeType));
// writer.WriteEndElement();
// break;
// }
//}
// Get Row Count
ITable table = dataset as ITable;
int intRowCount = -1;
if (table != null)
{
try {
intRowCount = table.RowCount(null);
}
catch { }
}
// <Dataset><RowCount>
writer.WriteStartElement("RowCount");
switch (intRowCount)
{
case -1:
writer.WriteValue("Error");
break;
case 0:
default:
writer.WriteValue(intRowCount.ToString());
break;
}
writer.WriteEndElement();
if (intRowCount > 0)
{
if (dataset is IGeoDataset)
{
IGeoDataset geoDataset = (IGeoDataset)dataset;
IEnvelope envelope = geoDataset.Extent;
if (envelope != null && !envelope.IsEmpty)
{
// <Dataset><Extent>
writer.WriteStartElement("Extent");
// <Dataset><Extent><XMax>
writer.WriteStartElement("XMax");
writer.WriteValue(envelope.XMax.ToString());
writer.WriteEndElement();
// <Dataset><Extent><XMin>
writer.WriteStartElement("XMin");
writer.WriteValue(envelope.XMin.ToString());
writer.WriteEndElement();
// <Dataset><Extent><YMax>
writer.WriteStartElement("YMax");
writer.WriteValue(envelope.YMax.ToString());
writer.WriteEndElement();
// <Dataset><Extent><YMin>
writer.WriteStartElement("YMin");
writer.WriteValue(envelope.YMin.ToString());
writer.WriteEndElement();
// <Dataset></Extent>
writer.WriteEndElement();
// <Dataset><SmallImage>
if (DataReportSettings.Default.ShowSmallImage)
{
string smallImage = System.IO.Path.GetTempFileName();
writer.WriteStartElement("SmallImage");
writer.WriteValue(smallImage);
writer.WriteEndElement();
GeodatabaseUtility.CreateBitmap(
dataset,
DataReportSettings.Default.SmallImageType,
DataReportSettings.Default.SmallImageSize,
DataReportSettings.Default.SmallImageResolution,
DataReportSettings.Default.SmallImageBackgroundColor,
smallImage);
}
// <Dataset><LargeImage>
if (DataReportSettings.Default.ShowLargeImage)
{
string largeImage = System.IO.Path.GetTempFileName();
writer.WriteStartElement("LargeImage");
writer.WriteValue(largeImage);
writer.WriteEndElement();
GeodatabaseUtility.CreateBitmap(
dataset,
DataReportSettings.Default.LargeImageType,
DataReportSettings.Default.LargeImageSize,
DataReportSettings.Default.LargeImageResolution,
DataReportSettings.Default.LargeImageBackgroundColor,
largeImage);
}
}
}
}
ISubtypes subtypes = dataset as ISubtypes;
if (subtypes != null && subtypes.HasSubtype)
{
int subtypeCode = 0;
IEnumSubtype enumSubtype = subtypes.Subtypes;
string subtypeName = enumSubtype.Next(out subtypeCode);
while (subtypeName != null)
{
// <Dataset><Sybtype>
writer.WriteStartElement("Subtype");
// <Dataset><Sybtype><Name>
writer.WriteStartElement("Name");
writer.WriteValue(subtypeName);
writer.WriteEndElement();
// Get Row Count
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = string.Format("{0} = {1}", subtypes.SubtypeFieldName, subtypeCode.ToString());
int rowCount = table.RowCount(queryFilter);
// <Dataset><Sybtype><RowCount>
writer.WriteStartElement("RowCount");
writer.WriteValue(rowCount.ToString());
writer.WriteEndElement();
// <Dataset></Sybtype>
writer.WriteEndElement();
// Get Next Subtype
subtypeName = enumSubtype.Next(out subtypeCode);
}
}
// </Dataset>
writer.WriteEndElement();
}
public override void Errors(List <Error> list)
{
// Field Name Null or Empty
if (string.IsNullOrEmpty(this._fieldName))
{
list.Add(new ErrorTableRow(this, "Subtype Field names cannot be empty", ErrorType.Error));
}
// Get DiagrammerEnvironment Singleton
DiagrammerEnvironment diagrammerEnvironment = DiagrammerEnvironment.Default;
SchemaModel schemaModel = diagrammerEnvironment.SchemaModel;
// Get Subtype
Subtype subtype = (Subtype)this.Table;
// Get ObjectClass
ObjectClass objectClass = subtype.GetParent();
if (objectClass == null)
{
// This error is handled by the Subtype class
return;
}
// Get Field
Field field = objectClass.FindField(this._fieldName);
if (field == null)
{
// Field is missing in parent ObjectClass
string message = string.Format("The subtype field [{0}] does not exist in the parent objectclass", this._fieldName);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
return;
}
// Warning if parent default value and domain are identical
if (this._defaultValue == field.DefaultValue &&
this._domainName == field.Domain)
{
string message = string.Format("The default values and domain for the subtype field [{0}] are identical to those in the parent objectclass", this._fieldName);
list.Add(new ErrorTableRow(this, message, ErrorType.Warning));
}
// Field can only be small int, long in, single, double, text, date, guid
switch (field.FieldType)
{
case esriFieldType.esriFieldTypeDate:
case esriFieldType.esriFieldTypeDouble:
case esriFieldType.esriFieldTypeGUID:
case esriFieldType.esriFieldTypeInteger:
case esriFieldType.esriFieldTypeSingle:
case esriFieldType.esriFieldTypeSmallInteger:
case esriFieldType.esriFieldTypeString:
// OK
break;
case esriFieldType.esriFieldTypeRaster:
case esriFieldType.esriFieldTypeBlob:
case esriFieldType.esriFieldTypeGeometry:
case esriFieldType.esriFieldTypeOID:
case esriFieldType.esriFieldTypeGlobalID:
case esriFieldType.esriFieldTypeXML:
string message = string.Format("The subtype field [{0}] must use a field of type Date, Double, Guid, Integer, Single, SmallInteger or String", this._fieldName);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
break;
}
// Find Domain
if (!string.IsNullOrEmpty(this._domainName))
{
// Get Domain
Domain domain = schemaModel.FindDomain(this._domainName);
if (domain == null)
{
// Domain does not exit
string message = string.Format("The domain [{0}] for field [{1}] does not exist", this._domainName, field.Name);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
}
else
{
// Compare domain and field types
if (field.FieldType != domain.FieldType)
{
string message = string.Format("The field [{0}] and assigned domain [{1}] do not have matching field types.", field.Name, this._domainName);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
}
// Check Default Value (
if (!string.IsNullOrEmpty(this._defaultValue))
{
string message = null;
if (!domain.IsValid(this._defaultValue, out message))
{
list.Add(new ErrorTableRow(this, message, ErrorType.Warning));
}
}
// Check if a domain value is too long for the text field
if (field.FieldType == esriFieldType.esriFieldTypeString &&
domain.FieldType == esriFieldType.esriFieldTypeString &&
domain.GetType() == typeof(DomainCodedValue))
{
DomainCodedValue domain2 = (DomainCodedValue)domain;
foreach (DomainCodedValueRow x in domain2.CodedValues)
{
if (string.IsNullOrEmpty(x.Code))
{
continue;
}
if (x.Code.Length > field.Length)
{
string message = string.Format("The domain [{0}] has a value [{1}] that is too long for the field [{2}]", this._domainName, x, this._fieldName);
list.Add(new ErrorTableRow(this, message, ErrorType.Error));
}
}
}
}
}
// Check validity of default value against field type
if (!string.IsNullOrEmpty(this._defaultValue))
{
string message;
if (!GeodatabaseUtility.IsValidateValue(field.FieldType, this._defaultValue, out message))
{
string message2 = string.Format("Default value [{0}] {1}", this._defaultValue, message);
list.Add(new ErrorTableRow(this, message2, ErrorType.Error));
}
}
//
if (!string.IsNullOrEmpty(this._defaultValue))
{
if (!string.IsNullOrEmpty(this._domainName))
{
if (!string.IsNullOrEmpty(field.Domain))
{
if (this._domainName != field.Domain)
{
Domain domain2 = schemaModel.FindDomain(field.Domain);
string message = null;
if (!domain2.IsValid(this._defaultValue, out message))
{
string message2 = string.Format("NIM013605: Field [{0}] - {1}", this._fieldName, message);
list.Add(new ErrorTableRow(this, message2, ErrorType.Error));
}
}
}
}
}
}
//
// CONSTRUCTOR
//
public NetworkAttribute(IXPathNavigable path) : base(path)
{
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <ID>
XPathNavigator navigatorID = navigator.SelectSingleNode("ID");
if (navigatorID != null)
{
this._id = navigatorID.ValueAsInt;
}
// <Name>
XPathNavigator navigatorName = navigator.SelectSingleNode("Name");
if (navigatorName != null)
{
this._name = navigatorName.Value;
}
// <Units>
XPathNavigator navigatorUnits = navigator.SelectSingleNode("Units");
if (navigatorUnits != null)
{
this._units = GeodatabaseUtility.GetNetworkAttributeUnits(navigatorUnits.Value);
}
// <DataType>
XPathNavigator navigatorDataType = navigator.SelectSingleNode("DataType");
if (navigatorDataType != null)
{
this._dataType = (esriNetworkAttributeDataType)Enum.Parse(typeof(esriNetworkAttributeDataType), navigatorDataType.Value, true);
}
// <UsageType>
XPathNavigator navigatorUsageType = navigator.SelectSingleNode("UsageType");
if (navigatorUsageType != null)
{
this._usageType = (esriNetworkAttributeUsageType)Enum.Parse(typeof(esriNetworkAttributeUsageType), navigatorUsageType.Value, true);
}
// <UserData><PropertyArray><PropertySetProperty>
this._userData = new List <Property>();
XPathNodeIterator interatorProperty = navigator.Select("UserData/PropertyArray/PropertySetProperty");
while (interatorProperty.MoveNext())
{
// Get <PropertySetProperty>
XPathNavigator navigatorProperty = interatorProperty.Current;
// Add PropertySetProperty
Property property = new Property(navigatorProperty);
this._userData.Add(property);
}
// <UseByDefault>
XPathNavigator navigatorUseByDefault = navigator.SelectSingleNode("UseByDefault");
if (navigatorUseByDefault != null)
{
this._useByDefault = navigatorUseByDefault.ValueAsBoolean;
}
// <AttributedParameters><AttributedParameter>
this._attributeParameters = new List <NetworkAttributeParameter>();
XPathNodeIterator interatorAttributedParameter = navigator.Select("AttributedParameters/AttributedParameter");
while (interatorAttributedParameter.MoveNext())
{
// Get <AttributedParameter>
XPathNavigator navigatorAttributedParameter = interatorAttributedParameter.Current;
// Add AttributedParameter
NetworkAttributeParameter networkAttributeParameter = new NetworkAttributeParameter(navigatorAttributedParameter);
this._attributeParameters.Add(networkAttributeParameter);
}
}
protected override void WriteInnerXml(XmlWriter writer)
{
// Call Base Method
base.WriteInnerXml(writer);
// <ID></ID>
writer.WriteStartElement("ID");
writer.WriteValue(this._id);
writer.WriteEndElement();
// <Name></Name>
writer.WriteStartElement("Name");
writer.WriteValue(this._name);
writer.WriteEndElement();
// <Units></Units>
writer.WriteStartElement("Units");
writer.WriteValue(GeodatabaseUtility.GetDescription(this._units));
writer.WriteEndElement();
// <DataType></DataType>
writer.WriteStartElement("DataType");
writer.WriteValue(this._dataType.ToString());
writer.WriteEndElement();
// <UsageType></UsageType>
writer.WriteStartElement("UsageType");
writer.WriteValue(this._usageType.ToString());
writer.WriteEndElement();
if (this._userData.Count == 0)
{
// <UserData></UserData>
writer.WriteStartElement("UserData");
writer.WriteAttributeString(Xml._XSI, "nil", null, "true");
writer.WriteEndElement();
}
else
{
// <UserData>
writer.WriteStartElement("UserData");
writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:PropertySet");
// <PropertyArray>
writer.WriteStartElement("PropertyArray");
writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:PropertyArray");
// <PropertySetProperty></PropertySetProperty>
foreach (Property property in this._userData)
{
property.WriteXml(writer);
}
// </PropertyArray>
writer.WriteEndElement();
// </UserData>
writer.WriteEndElement();
}
// <UseByDefault></UseByDefault>
writer.WriteStartElement("UseByDefault");
writer.WriteValue(this._useByDefault);
writer.WriteEndElement();
// <AttributeParameters>
writer.WriteStartElement("AttributeParameters");
writer.WriteAttributeString(Xml._XSI, Xml._TYPE, null, "esri:ArrayOfNetworkAttributeParameter");
// <NetworkAttributeParameter></NetworkAttributeParameter>
foreach (NetworkAttributeParameter networkAttributeParameter in this._attributeParameters)
{
networkAttributeParameter.WriteXml(writer);
}
// </AttributeParameters>
writer.WriteEndElement();
}
//
// PROTECTED METHODS
//
protected override void WriteInnerXml(XmlWriter writer)
{
// Write Inner Xml
base.WriteInnerXml(writer);
// <HasOID>
bool hasOID = !string.IsNullOrEmpty(this._oidFieldName);
writer.WriteStartElement("HasOID");
writer.WriteValue(hasOID);
writer.WriteEndElement();
// <OIDFieldName>
writer.WriteStartElement("OIDFieldName");
writer.WriteValue(this._oidFieldName);
writer.WriteEndElement();
// <Fields>
TableGroup tableGroupField = (TableGroup)base.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)base.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></Index>
foreach (Index index in tableGroupIndex.Groups)
{
index.WriteXml(writer);
}
// </IndexArray>
writer.WriteEndElement();
// </Indexes>
writer.WriteEndElement();
// <IsInteger>
writer.WriteStartElement("IsInteger");
writer.WriteValue(this._isInteger);
writer.WriteEndElement();
// <MeanCellHeight>
writer.WriteStartElement("MeanCellHeight");
writer.WriteValue(this._meanCellHeight);
writer.WriteEndElement();
// <MeanCellWidth>
writer.WriteStartElement("MeanCellWidth");
writer.WriteValue(this._meanCellWidth);
writer.WriteEndElement();
// <Height>
writer.WriteStartElement("Height");
writer.WriteValue(this._height);
writer.WriteEndElement();
// <Width>
writer.WriteStartElement("Width");
writer.WriteValue(this._width);
writer.WriteEndElement();
// <PixelType>
writer.WriteStartElement("PixelType");
writer.WriteValue(GeodatabaseUtility.GetDescription(this._pixelType));
writer.WriteEndElement();
// <PrimaryField>
writer.WriteStartElement("PrimaryField");
writer.WriteValue(this._primaryField);
writer.WriteEndElement();
// <TableType>
writer.WriteStartElement("TableType");
writer.WriteValue(this._tableType.ToString());
writer.WriteEndElement();
// <Extent>
if (this._extent != null)
{
this._extent.WriteXml(writer);
}
// <SpatialReference>
if (this._spatialReference != null)
{
this._spatialReference.WriteXml(writer);
}
}
//
// CONSTRUCTOR
//
public RasterBand(IXPathNavigable path) : base(path)
{
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <OIDFieldName>
XPathNavigator navigatorOIDFieldName = navigator.SelectSingleNode("OIDFieldName");
if (navigatorOIDFieldName != null)
{
this._oidFieldName = navigatorOIDFieldName.Value;
}
// Create Fields Group
TableGroup tableGroupFields = new TableGroup();
tableGroupFields.Expanded = true;
tableGroupFields.Text = "Fields";
this.Groups.Add(tableGroupFields);
XPathNodeIterator interatorField = navigator.Select("Fields/FieldArray/Field");
while (interatorField.MoveNext())
{
// Create Field
XPathNavigator navigatorField = interatorField.Current;
Field field = new Field(navigatorField, this);
// Add Field To Group
tableGroupFields.Rows.Add(field);
}
// Create Indexes Group
TableGroup tableGroupIndexes = new TableGroup();
tableGroupIndexes.Expanded = true;
tableGroupIndexes.Text = "Indexes";
this.Groups.Add(tableGroupIndexes);
XPathNodeIterator interatorIndex = navigator.Select("Indexes/IndexArray/Index");
while (interatorIndex.MoveNext())
{
// Add Index
XPathNavigator navigatorIndex = interatorIndex.Current;
Index index = new Index(navigatorIndex);
tableGroupIndexes.Groups.Add(index);
// Add Field Index
XPathNodeIterator interatorIndexField = navigatorIndex.Select("Fields/FieldArray/Field");
while (interatorIndexField.MoveNext())
{
XPathNavigator navigatorIndexField = interatorIndexField.Current;
IndexField indexField = new IndexField(navigatorIndexField);
index.Rows.Add(indexField);
}
}
// <IsInteger>
XPathNavigator navigatorIsInteger = navigator.SelectSingleNode("IsInteger");
if (navigatorIsInteger != null)
{
this._isInteger = navigatorIsInteger.ValueAsBoolean;
}
// <MeanCellHeight>
XPathNavigator navigatorMeanCellHeight = navigator.SelectSingleNode("MeanCellHeight");
if (navigatorMeanCellHeight != null)
{
this._meanCellHeight = navigatorMeanCellHeight.ValueAsDouble;
}
// <MeanCellWidth>
XPathNavigator navigatorMeanCellWidth = navigator.SelectSingleNode("MeanCellWidth");
if (navigatorMeanCellWidth != null)
{
this._meanCellWidth = navigatorMeanCellWidth.ValueAsDouble;
}
// <Height>
XPathNavigator navigatorHeight = navigator.SelectSingleNode("Height");
if (navigatorHeight != null)
{
this._height = navigatorHeight.ValueAsInt;
}
// <Width>
XPathNavigator navigatorWidth = navigator.SelectSingleNode("Width");
if (navigatorWidth != null)
{
this._width = navigatorWidth.ValueAsInt;
}
// <PixelType>
XPathNavigator navigatorPixelType = navigator.SelectSingleNode("PixelType");
if (navigatorPixelType != null)
{
this._pixelType = GeodatabaseUtility.GetPixelType(navigatorPixelType.Value);
}
// <PrimaryField>
XPathNavigator navigatorPrimaryField = navigator.SelectSingleNode("PrimaryField");
if (navigatorPrimaryField != null)
{
this._primaryField = navigatorPrimaryField.ValueAsInt;
}
// <TableType>
XPathNavigator navigatorTableType = navigator.SelectSingleNode("TableType");
if (navigatorTableType != null)
{
this._tableType = (esriRasterTableTypeEnum)Enum.Parse(typeof(esriRasterTableTypeEnum), navigatorTableType.Value, true);
}
// <Extent>
XPathNavigator navigatorExtent = navigator.SelectSingleNode("Extent");
if (navigatorExtent != null)
{
this._extent = new Extent(navigatorExtent);
}
else
{
this._extent = new Extent();
}
// <SpatialReference>
XPathNavigator navigatorSpatialReference = navigator.SelectSingleNode("SpatialReference");
if (navigatorSpatialReference != null)
{
this._spatialReference = new SpatialReference(navigatorSpatialReference);
}
else
{
this._spatialReference = new SpatialReference();
}
}
/// <summary>
/// Create Bitmap From ESRI Dataset
/// </summary>
/// <param name="dataset">Dataset to generate an image from</param>
/// <param name="imageFormat">Output image format</param>
/// <param name="size">Size of output image</param>
/// <param name="resolution">Resolution of output image (dpi)</param>
/// <param name="background">Background color</param>
/// <param name="filename">Ouput filename</param>
public static void CreateBitmap(IDataset dataset, esriImageFormat imageFormat, Size size, ushort resolution, Color background, string filename)
{
ILayer layer = null;
switch (dataset.Type)
{
case esriDatasetType.esriDTFeatureClass:
IFeatureClass featureClass = (IFeatureClass)dataset;
switch (featureClass.FeatureType)
{
case esriFeatureType.esriFTDimension:
layer = new DimensionLayerClass();
break;
case esriFeatureType.esriFTAnnotation:
layer = new FeatureLayerClass();
IGeoFeatureLayer geoFeaureLayer = (IGeoFeatureLayer)layer;
geoFeaureLayer.DisplayAnnotation = true;
break;
case esriFeatureType.esriFTComplexEdge:
case esriFeatureType.esriFTComplexJunction:
case esriFeatureType.esriFTSimple:
case esriFeatureType.esriFTSimpleEdge:
case esriFeatureType.esriFTSimpleJunction:
layer = new FeatureLayerClass();
break;
}
if (layer == null)
{
return;
}
IFeatureLayer featureLayer = (IFeatureLayer)layer;
featureLayer.FeatureClass = featureClass;
break;
case esriDatasetType.esriDTRasterDataset:
layer = new RasterLayerClass();
IRasterLayer rasterLayer = (IRasterLayer)layer;
rasterLayer.CreateFromDataset((IRasterDataset)dataset);
break;
default:
string message = string.Format("[{0}] is not supported", dataset.Type.ToString());
throw new Exception(message);
}
if (layer == null)
{
return;
}
// Create In-memory Map
IMap map = new MapClass();
map.AddLayer(layer);
IActiveView activeView = (IActiveView)map;
IExport export = null;
tagRECT rect = new tagRECT();
// Set Format Specific Properties
switch (imageFormat)
{
case esriImageFormat.esriImageJPG:
export = new ExportJPEGClass();
IExportJPEG exportJpeg = (IExportJPEG)export;
exportJpeg.ProgressiveMode = false;
exportJpeg.Quality = 100;
break;
default:
throw new Exception("[" + imageFormat.ToString() + "] is not supported");
}
if (export == null)
{
throw new Exception("Failed to Created Exporter");
}
// Set Background
if ((export is IExportBMP) ||
(export is IExportGIF) ||
(export is IExportJPEG) ||
(export is IExportPNG) ||
(export is IExportTIFF))
{
IExportImage exportImage = (IExportImage)export;
exportImage.ImageType = esriExportImageType.esriExportImageTypeTrueColor;
exportImage.BackgroundColor = GeodatabaseUtility.ToESRIColor(background);
}
// Set Export Frame
rect = activeView.ExportFrame;
rect.left = 0;
rect.top = 0;
rect.right = size.Width;
rect.bottom = size.Height;
// Set Output Extent
IEnvelope envelope = new EnvelopeClass();
envelope.PutCoords(rect.left, rect.top, rect.right, rect.bottom);
export.PixelBounds = envelope;
export.Resolution = resolution;
export.ExportFileName = filename;
// Export map to image
int intHdc = export.StartExporting();
activeView.Output(intHdc, resolution, ref rect, null, null);
export.FinishExporting();
export.Cleanup();
// Clear Layers
map.ClearLayers();
// Release COM Objects
GeodatabaseUtility.ReleaseComObject(layer);
GeodatabaseUtility.ReleaseComObject(envelope);
GeodatabaseUtility.ReleaseComObject(map);
GeodatabaseUtility.ReleaseComObject(activeView);
GeodatabaseUtility.ReleaseComObject(export);
GC.Collect();
GC.WaitForPendingFinalizers();
}
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;
}
}
}