public CosmoDbFeatureCursor(CosmoDbFeatureClass fc, IQueryFilter filter)
: base(fc.SpatialReference, filter.FeatureSpatialReference)
{
string sql = String.Empty;
if (filter is ISpatialFilter)
{
ISpatialFilter sFilter = (ISpatialFilter)filter;
var env = sFilter.Geometry.Envelope;
env.minx = Math.Max(-170, env.minx);
env.miny = Math.Max(-80, env.miny);
env.maxx = Math.Min(170, env.maxx);
env.maxy = Math.Min(80, env.maxy);
//sql = $"SELECT e._shape FROM everything e WHERE e._fc='{fc.Name}' AND ST_WITHIN(e._shape, {{'type':'Polygon', 'coordinates': [[[{env.miny.ToString(_nhi)}, {env.minx.ToString(_nhi)}], [{env.maxy.ToString(_nhi)}, {env.minx.ToString(_nhi)}], [{env.maxy.ToString(_nhi)}, {env.maxx.ToString(_nhi)}], [{env.miny.ToString(_nhi)}, {env.maxx.ToString(_nhi)}], [{env.miny.ToString(_nhi)}, {env.minx.ToString(_nhi)}]]]}})";
sql = $"SELECT e._shape FROM everything e WHERE e._fc='{fc.Name}' AND ST_WITHIN(e._shape, {{'type':'Polygon', 'coordinates': [[[{env.minx.ToString(_nhi)}, {env.miny.ToString(_nhi)}], [{env.maxx.ToString(_nhi)}, {env.miny.ToString(_nhi)}], [{env.maxx.ToString(_nhi)}, {env.maxy.ToString(_nhi)}], [{env.minx.ToString(_nhi)}, {env.maxy.ToString(_nhi)}], [{env.minx.ToString(_nhi)}, {env.miny.ToString(_nhi)}]]]}})";
}
else
{
sql = $"SELECT * FROM everything e WHERE e._fc='{fc.Name}'";
}
//var query =
// fc.CosmoDocumentClient.CreateDocumentQuery(fc.CosmoDocumentCollection.SelfLink, sql)
// .AsEnumerable()
// .ToArray();
_query =
fc.CosmoDocumentClient.CreateDocumentQuery(fc.CosmoDocumentCollection.SelfLink, sql)
.AsDocumentQuery();
}
public void SetInfo(DF3DFeatureClass dffc, ISpatialFilter filter, int count)
{
_count = count;
_filter = filter;
this.cbLayer.Properties.Items.Add(dffc);
this.cbLayer.SelectedIndex = 0;
}
private static bool FeatureLayerIdentify(IBasicMap ibasicMap_0, IFeatureLayer ifeatureLayer_0,
IGeometry igeometry_0, IList <object> ilist_0)
{
bool flag;
ISpatialFilter spatialFilterClass = new SpatialFilter()
{
Geometry = igeometry_0,
SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects
};
ISpatialFilter spatialFilter = spatialFilterClass;
try
{
IFeatureCursor featureCursor = ifeatureLayer_0.FeatureClass.Search(spatialFilter, false);
for (IFeature i = featureCursor.NextFeature(); i != null; i = featureCursor.NextFeature())
{
AEFeatureIdentifyObject aEFeatureIdentifyObject = new AEFeatureIdentifyObject()
{
BasicMap = ibasicMap_0,
Feature = i
};
ilist_0.Add(aEFeatureIdentifyObject);
}
flag = true;
return(flag);
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
flag = false;
return(flag);
}
public GeoJsonFeatureCursor(GeoJsonServiceFeatureClass fc, IEnumerable <IFeature> features, IQueryFilter filter)
: base(fc?.SpatialReference, filter?.FeatureSpatialReference)
{
_features = features?.ToArray();
_queryFilter = filter;
_spatialFilter = filter as ISpatialFilter;
}
public IFeatureCursor SearchFeatureCursorFromFeatureClass(IFeatureClass pFClass, IGeometry pFilterGeometry, esriSpatialRelEnum enumSpatialRel)
{
try
{
if (pFClass == null)
{
return(null);
}
ISpatialFilter filter = null;
if (pFilterGeometry == null)
{
filter = null;
}
else
{
filter = new SpatialFilterClass {
Geometry = pFilterGeometry,
GeometryField = pFClass.ShapeFieldName,
SpatialRel = enumSpatialRel
};
}
return(pFClass.Search(filter, false));
}
catch (Exception exception)
{
this.mErrOpt.ErrorOperate(this.mSubSysName, "FunFactory.FeatureFun", "SearchFeatureCursorFromFeatureClass", exception.GetHashCode().ToString(), exception.Source, exception.Message, "", "", "");
return(null);
}
}
private IFeature isGeometrySearched(IFeatureClass iFeatureClass, IGeometry searchGeo, esriSpatialRelEnum SpatialRel)
{
IFeatureCursor iFeatureCursor = null;
IFeature iFeature = null;
ISpatialFilter iSpatialFilter = null;
try
{
iSpatialFilter = new SpatialFilter();
iSpatialFilter.Geometry = searchGeo;
iSpatialFilter.SpatialRel = SpatialRel;
iFeatureCursor = iFeatureClass.Search(iSpatialFilter, false);
iFeature = iFeatureCursor.NextFeature();
if (iFeature != null)
{
return(iFeature);
}
else
{
return(null);
}
}
catch
{
return(null);
}
finally
{
//注意不要释放了IFeature外面还要用
m_SDEUtils.ReleaseComObject(iFeatureCursor);
m_SDEUtils.ReleaseComObject(iSpatialFilter);
}
}
private IEnumerable <IFeature> GetConnectedBorderFeatures(
[NotNull] IGeometry geometry,
[NotNull] IFeature geometryFeature, int geometryClassIndex,
int borderClassIndex,
[NotNull] Func <ITable, IQueryFilter, QueryFilterHelper, IEnumerable <IRow> > search,
ITable borderClass,
ISpatialFilter spatialFilter,
QueryFilterHelper filterHelper,
RowPairCondition borderMatchCondition)
{
spatialFilter.Geometry = geometry;
var result = new List <IFeature>(5);
foreach (IRow borderRow in search(borderClass,
spatialFilter,
filterHelper))
{
if (!borderMatchCondition.IsFulfilled(geometryFeature, geometryClassIndex,
borderRow, borderClassIndex))
{
continue;
}
result.Add((IFeature)borderRow);
}
return(result);
}
private ICollection <IFeature> GetConnectedBorderFeatures(
[NotNull] IPoint point,
[NotNull] IFeature lineFeature, int lineClassIndex,
int borderClassIndex)
{
ITable borderClass = InvolvedTables[borderClassIndex];
ISpatialFilter spatialFilter = _filters[borderClassIndex];
spatialFilter.Geometry = point;
var result = new List <IFeature>(5);
BorderMatchCondition borderMatchCondition =
GetBorderMatchCondition(lineClassIndex);
foreach (IRow borderRow in Search(borderClass,
spatialFilter,
_filterHelpers[borderClassIndex]))
{
if (!borderMatchCondition.IsFulfilled(lineFeature, lineClassIndex,
borderRow, borderClassIndex))
{
continue;
}
result.Add((IFeature)borderRow);
}
return(result);
}
private IGeometryCollection GetIntersectSameTypeFeatures(IFeatureClass pFc, IFeature pFeature, ISpatialFilter spatialFilter, IQueryFilter filter, string unionType, string unionValue, ref ArrayList fIDs)
{
object missing = Type.Missing;
//object fID = pFeature.get_Value(pFeature.Fields.FindField("FID"));
spatialFilter.GeometryField = "Shape";
spatialFilter.Geometry = pFeature.Shape;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
if (currentFieldType == esriFieldType.esriFieldTypeString)
{
spatialFilter.WhereClause = unionType + " = " + "'" + unionValue + "'";
}
else if (currentFieldType == esriFieldType.esriFieldTypeDate)
{
//filter.WhereClause = unionType + " = " + "'" + unionValue + "'";
}
else
{
spatialFilter.WhereClause = unionType + " = " + unionValue;
}
filter = spatialFilter;
IGeometryCollection pGeoCollection = new GeometryBagClass() as IGeometryCollection;
IFeatureCursor pFeatureCursor = pFc.Search(filter, true);
IFeature pF = pFeatureCursor.NextFeature();
while (pF != null)
{
fIDs.Add(pF.get_Value(pF.Fields.FindField("FID")));
pGeoCollection.AddGeometry(pF.ShapeCopy, ref missing, ref missing);
pF = pFeatureCursor.NextFeature();
}
Marshal.ReleaseComObject(pFeatureCursor);
return(pGeoCollection);
}
private bool CheckTable([NotNull] IPoint point,
[NotNull] IFeatureClass neighbor,
int tableIndex)
{
ISpatialFilter filter = _filter[tableIndex];
point.QueryEnvelope(_box);
_box.Expand(SearchDistance, SearchDistance, false);
filter.Geometry = _box;
foreach (IRow row in
Search((ITable)neighbor, _filter[tableIndex], _helper[tableIndex], point))
{
var neighborFeature = (IFeature)row;
double distance = GetDistance(point, neighborFeature);
if (distance <= SearchDistance)
{
return(true);
}
}
return(false);
}
protected IEnumerable <IRow> Search(
int involvedTableIndex,
[NotNull] IGeometry geometry,
esriSpatialRelEnum spatialRelation = esriSpatialRelEnum.esriSpatialRelIntersects,
[CanBeNull] string where = null)
{
EnsureDefaultFilters();
ITable table = InvolvedTables[involvedTableIndex];
ISpatialFilter filter = _defaultFilters[involvedTableIndex];
QueryFilterHelper defaultHelper = _defaultFilterHelpers[involvedTableIndex];
QueryFilterHelper whereHelper = (string.IsNullOrWhiteSpace(where))
? new QueryFilterHelper(
table, where, GetSqlCaseSensitivity(table))
: null;
filter.Geometry = geometry;
filter.SpatialRel = spatialRelation;
foreach (var row in Search(table, filter, defaultHelper))
{
if (whereHelper == null || whereHelper.MatchesConstraint(row))
{
yield return(row);
}
}
}
public gView.Framework.Data.ISelectionSet Select(gView.Framework.Data.IQueryFilter filter)
{
if (filter is IBufferQueryFilter)
{
ISpatialFilter sFilter = BufferQueryFilter.ConvertToSpatialFilter(filter as IBufferQueryFilter);
if (sFilter == null)
{
return(null);
}
return(Select(sFilter));
}
filter.SubFields = this.IDFieldName;
IFeatureCursor cursor = (IFeatureCursor)(new ShapeFeatureCursor(this, _file, filter, _tree));
IFeature feat;
IDSelectionSet selSet = new IDSelectionSet();
while ((feat = cursor.NextFeature) != null)
{
selSet.AddID((int)((uint)feat.OID));
}
cursor.Dispose();
return(selSet);
}
protected override int ExecuteCore(IRow row, int tableIndex)
{
if (_spatialFilter == null)
{
InitFilter();
_spatialFilter = Assert.NotNull(_spatialFilter, "filter is null");
}
// configure filter to find crossing "row"
IGeometry shape = ((IFeature)row).Shape;
_spatialFilter.Geometry = shape;
// optimize query if tests runs "directed"
_selectHelper.MinimumOID = IgnoreUndirected
? row.OID
: -1;
var errorCount = 0;
ITable table = InvolvedTables[0];
foreach (IRow touchingRow in Search(table, _spatialFilter, _selectHelper))
{
errorCount += CheckRows(row, shape, (IFeature)touchingRow);
}
return(errorCount);
}
public void SetResult(IFeatureCursor cursor, IFeatureSelection selection, ISpatialFilter spatialFilter)
{
_cursor = cursor;
_selection = selection;
_spatialFilter = spatialFilter;
InitCombos();
}
private bool IsCoincidentWithNeighborBorder(
[NotNull] BorderConnection borderConnection,
[NotNull] IFeature neighborFeature, int neighborLineClassIndex,
int neighborBorderClassIndex)
{
ITable neighborBorderClass = InvolvedTables[neighborBorderClassIndex];
ISpatialFilter spatialFilter = _filters[neighborBorderClassIndex];
spatialFilter.Geometry = borderConnection.Point;
BorderMatchCondition neighborBorderMatchCondition =
GetBorderMatchCondition(neighborLineClassIndex);
foreach (IRow borderRow in Search(neighborBorderClass,
spatialFilter,
_filterHelpers[neighborBorderClassIndex]))
{
if (neighborBorderMatchCondition.IsFulfilled(neighborFeature,
neighborLineClassIndex,
borderRow,
neighborBorderClassIndex))
{
return(true);
}
}
return(false);
}
protected override int ExecuteCore(IRow row, int tableIndex)
{
if (tableIndex > 0)
{
return(NoError);
}
if (_filter == null)
{
InitFilter();
}
ISpatialFilter filter = Assert.NotNull(_filter, "_filter");
var processed0 = new SegmentNeighbors(new SegmentPartComparer());
IGeometry geom0 = ((IFeature)row).Shape;
IEnvelope box0 = geom0.Envelope;
box0.Expand(SearchDistance, SearchDistance, false);
filter.Geometry = box0;
var errorCount = 0;
double maxNear = SearchDistance;
const int neighborTableIndex = 1;
IFeatureRowsDistance rowsDistance =
NearDistanceProvider.GetRowsDistance(row, tableIndex);
foreach (IRow neighborRow in
Search((ITable)_reference, filter, _helper, geom0))
{
var rowNeighbor = (IFeature)neighborRow;
if (IgnoreNeighbor(row, neighborRow))
{
continue;
}
SegmentNeighbors processed1;
var neighborKey = new RowKey(rowNeighbor, neighborTableIndex);
if (!ProcessedList.TryGetValue(neighborKey, out processed1))
{
processed1 = new SegmentNeighbors(new SegmentPartComparer());
ProcessedList.Add(neighborKey, processed1);
}
NeighborhoodFinder finder =
GetNeighborhoodFinder(rowsDistance, (IFeature)row, tableIndex,
rowNeighbor, neighborTableIndex);
errorCount += FindNeighborhood(finder, tableIndex, processed0,
neighborTableIndex, processed1,
maxNear);
}
return(errorCount);
}
private void query()
{
if (this.cmbLayer.SelectedItem == null)
{
return;
}
DF3DFeatureClass dffc = this.cmbLayer.SelectedItem as DF3DFeatureClass;
IFeatureClass fc = dffc.GetFeatureClass();
if (fc == null)
{
return;
}
ISpatialFilter filter = new SpatialFilter();
#region
if (this.cmbField.SelectedItem == null)
{
filter.WhereClause = "1=1";
}
else
{
if (this.cmbField.SelectedItem is DFDataConfig.Class.FieldInfo)
{
DFDataConfig.Class.FieldInfo fi = this.cmbField.SelectedItem as DFDataConfig.Class.FieldInfo;
if (oper == " like ")
{
filter.WhereClause = fi.Name + " like '%" + this.teFieldValue.Text + "%'";
}
else
{
if (fi.DataType.ToLower() == "decimal")
{
filter.WhereClause = fi.Name + oper + this.teFieldValue.Text;
}
else
{
filter.WhereClause = fi.Name + oper + "'" + this.teFieldValue.Text + "'";
}
}
}
else
{
filter.WhereClause = "1!=1";
}
}
#endregion
int count = fc.GetCount(filter);
if (count == 0)
{
XtraMessageBox.Show("查询结果为空", "提示");
return;
}
this._dffc = dffc;
this._filter = filter;
this._total = count;
this.DialogResult = System.Windows.Forms.DialogResult.OK;
}
/// <summary>
/// Converte una Feature Class, opportunamente filtrata in un oggetto RecordSet
/// </summary>
/// <param name="featureClass"></param>
/// <param name="spatialFilter"></param>
/// <returns></returns>
internal static IRecordSet2 ConvertToRecordset(IFeatureClass featureClass, ISpatialFilter spatialFilter)
{
IRecordSet recordSet = new RecordSetClass();
IRecordSetInit recordSetInit = recordSet as IRecordSetInit;
recordSetInit.SetSourceTable(featureClass as ITable, spatialFilter);
return((IRecordSet2)recordSetInit);
}
/// 校验表达式是否合法
private bool CheckExpression(string sExpression, bool bShow)
{
if (m_pCurrentLayer == null)
{
return(false);
}
//获取当前图层的 featureclass
IFeatureClass pFeatCls = m_pCurrentLayer.FeatureClass;
//构造查询过滤器
IQueryFilter pFilter = null;
if (m_pGeometryFilter == null)
{
pFilter = new QueryFilterClass();
}
else
{
pFilter = new SpatialFilterClass();
ISpatialFilter pSpatialFilter = pFilter as ISpatialFilter;
pSpatialFilter.Geometry = m_pGeometryFilter;
pSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
}
try
{
//赋值查许条件
pFilter.WhereClause = sExpression;
//得到查询结果
int intCount = pFeatCls.FeatureCount(pFilter);
if (intCount > 0)
{
if (bShow == true)
{
SysCommon.Error.ErrorHandle.ShowFrmErrorHandle("系统提示", "表达式正确!");
}
return(true);
}
else
{
if (bShow == true)
{
SysCommon.Error.ErrorHandle.ShowFrmErrorHandle("系统提示", "表达式正确，但搜索不到要素,请检查表达式");
}
return(false);
}
}
catch
{
if (bShow == true)
{
SysCommon.Error.ErrorHandle.ShowFrmErrorHandle("系统提示", "表达式书写有误,请检查表达式");
}
return(false);
}
}
private static ISpatialFilter CreateIntersectionFilter(
[NotNull] ISpatialFilter defaultFilter)
{
var filter = (ISpatialFilter)((IClone)defaultFilter).Clone();
filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
filter.SpatialRelDescription = null;
return(filter);
}
private void InitFilter()
{
IList <ISpatialFilter> filter;
IList <QueryFilterHelper> helper;
CopyFilters(out filter, out helper);
_filter = filter[1];
_helper = helper[1];
_filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
}
public IEnumerable <T> GetBorderConnections <TG>(
[NotNull] TG geometry,
[NotNull] IFeature geometryFeature,
int geometryClassIndex,
int borderClassIndex,
ITable borderClass,
ISpatialFilter spatialFilter,
QueryFilterHelper filterHelper,
Func <ITable, IQueryFilter, QueryFilterHelper, IEnumerable <IRow> > search,
RowPairCondition borderMatchCondition)
where TG : IGeometry
{
var geometryKey = new FeatureKey(geometryFeature.OID, geometryClassIndex);
Dictionary <FeatureKey, T> borderConnections;
if (!_cache.TryGetValue(geometryKey, out borderConnections))
{
borderConnections = new Dictionary <FeatureKey, T>(new FeatureKeyComparer());
_cache.Add(geometryKey, borderConnections);
}
IPolyline geometryLine = geometry is IPolyline
? (IPolyline)geometry
: (IPolyline)((ITopologicalOperator)geometry).Boundary;
IEnumerable <IFeature> borderFeatures =
GetConnectedBorderFeatures(geometry, geometryFeature, geometryClassIndex,
borderClassIndex, search, borderClass, spatialFilter,
filterHelper, borderMatchCondition);
foreach (IFeature borderFeature in borderFeatures)
{
var borderKey = new FeatureKey(borderFeature.OID, borderClassIndex);
T borderConnection;
if (!borderConnections.TryGetValue(borderKey, out borderConnection))
{
IPolyline geometryAlongBorder = GetGeometryAlongBorder(borderFeature,
geometryLine);
borderConnection = CreateBorderConnection(geometryFeature, geometryClassIndex,
borderFeature,
borderClassIndex,
geometryAlongBorder,
geometryAlongBorder);
borderConnections.Add(borderKey, borderConnection);
}
}
return(new List <T>(borderConnections.Values));
}
public override IEnumerable <IRow> Search(IQueryFilter filter, bool recycling)
{
var filterHelper = FilterHelper.Create(_schema, filter.WhereClause);
ISpatialFilter spatialFilter = filter as ISpatialFilter;
bool hasSpatialFilter = spatialFilter?.Geometry != null;
return(AllRows.Where(r => filterHelper.Check(r) &&
(!hasSpatialFilter || CheckSpatial(r, spatialFilter))));
}
private void ClassQuery(MajorClass mc, MajorClass mctemp, ISpatialFilter filter, IGeometry geo)
{
if (mc == null || filter == null || geo == null)
{
return;
}
string[] arrFc3DId = mc.Fc3D.Split(';');
if (arrFc3DId == null)
{
return;
}
foreach (SubClass sc in mc.SubClasses)
{
if (!sc.Visible3D)
{
continue;
}
bool bHave = false;
foreach (string fc3DId in arrFc3DId)
{
DF3DFeatureClass dffc = DF3DFeatureClassManager.Instance.GetFeatureClassByID(fc3DId);
if (dffc == null)
{
continue;
}
FacilityClass facc = dffc.GetFacilityClass();
IFeatureClass fc = dffc.GetFeatureClass();
if (fc == null || facc == null)
{
continue;
}
filter.WhereClause = "GroupId = " + sc.GroupId;
int count = fc.GetCount(filter);
if (count == 0)
{
continue;
}
bHave = true;
bHaveRes = true;
if (bHave)
{
break;
}
}
if (bHave)
{
SubClass sctemp = new SubClass(sc.Name, sc.GroupId, sc.Parent);
sctemp.Visible3D = sc.Visible3D;
mctemp.SubClasses.Add(sctemp);
}
}
}
//<CSCM>
//********************************************************************************
//** 函 数 名: GetCursorByFieldAndValue
//** 版 权: CopyRight (C)
//** 创 建 人: 杨旭斌
//** 功能描述: 给出查询信息后,返回一个满足范围的光标
//
//** 创建日期:
//** 修 改 人:
//** 修改日期:
//** 修改时间: 20070817
//** 参数列表: sValue (String)
// sFieldName (String)
// pFeatCls (IFeatureClass)
//** 版 本:1.0
//*********************************************************************************
//</CSCM>
public static IFeatureCursor GetFeatCursor(IFeatureClass pFeatCls, string sSQLExpress, esriSpatialRelEnum EnumSpatialRel,
ref IGeometry pDomainGeometry, bool bGetFeatCount, ref long lFeatCount)
{
//sSQLExpress = "";
//EnumSpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
//pDomainGeometry = null;
//bGetFeatCount = false;
//lFeatCount = 0;
IFeatureCursor functionReturnValue = default(IFeatureCursor);
ISpatialFilter pSpatialfilter = default(ISpatialFilter);
ITopologicalOperator2 pTopoOperator = default(ITopologicalOperator2);
IFeatureCursor pFeatCursor = default(IFeatureCursor);
// ERROR: Not supported in C#: OnErrorStatement
try
{
if (pFeatCls == null)
{
functionReturnValue = null;
return(functionReturnValue);
}
pSpatialfilter = new SpatialFilter();
pSpatialfilter.WhereClause = sSQLExpress;
//范围一起查询,提高查询效率
if (pDomainGeometry != null)
{
pTopoOperator = (ITopologicalOperator2)pDomainGeometry;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
pSpatialfilter.Geometry = (IGeometry)pTopoOperator;
pSpatialfilter.SpatialRel = EnumSpatialRel;
}
//获得一个新的选择集
pFeatCursor = pFeatCls.Search(pSpatialfilter, false);
//如果需要获得要满足条件的个数，则获得
if (bGetFeatCount)
{
lFeatCount = pFeatCls.FeatureCount(pSpatialfilter);
}
functionReturnValue = pFeatCursor;
return(functionReturnValue);
}
catch (System.Runtime.InteropServices.COMException ex)
{
if (ex.ErrorCode == -2147216117)
{
MessageBoxEx.Show("失去了与SDE服务器的连接,提取失败！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
}
functionReturnValue = null;
return(functionReturnValue);
}
}
private List <IFeature> _listF; //声明各区域包含的要素列表
public override Dictionary <string, List <IFeature> > GetStatsResult()
{
try
{
if (this._fc == null || this._district == null)
{
return(null);
}
disCursor = _district.Search(null, true);
if (disCursor == null)
{
return(null);
}
_dict = new Dictionary <string, List <IFeature> >();
while ((disFeature = disCursor.NextFeature()) != null)
{
IGeometry geo = disFeature.Shape;
filter = new SpatialFilter();
filter.Geometry = geo;
filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelContains;
fcCursor = _fc.Search(filter, true);
if (fcCursor == null)
{
continue;
}
int buildingCount = _fc.FeatureCount(filter);
disName = disFeature.get_Value(IndexOfDisName).ToString();
disArea = Convert.ToDouble(disFeature.get_Value(IndexOfDisArea));
double buildingArea = 0;
double floorArea = 0;
_listF = new List <IFeature>();
while ((fcFeature = fcCursor.NextFeature()) != null)
{
buildingArea += Convert.ToDouble(fcFeature.get_Value(IndexOfFcArea));
floorArea += Convert.ToDouble(fcFeature.get_Value(IndexOfFloorArea));
_listF.Add(fcFeature);
}
_dict[disName] = _listF;
DataRow row = _dt.NewRow();
row["DISTRICTNAME"] = disName;
row["DISTRICTAREA"] = Math.Round(disArea, 2);
row["NUMBER"] = buildingCount;
row["AREA"] = Math.Round(buildingArea, 2);
row["FLOORAREA"] = Math.Round(floorArea, 2);
_dt.Rows.Add(row);
}
}
catch (System.Exception ex)
{
}
return(_dict);
}
private ISpatialFilter PrepareSpatialFilter([NotNull] IPoint point,
int referenceClassIndex)
{
point.QueryEnvelope(_box);
_box.Expand(SearchDistance, SearchDistance, false);
ISpatialFilter filter = _filter[referenceClassIndex];
filter.Geometry = _box;
return(filter);
}
/// <summary>
/// create a filter that gets the lines crossing the current row,
/// with the same attribute constraints as the table
/// </summary>
private void InitFilter()
{
IList <ISpatialFilter> pFilters;
IList <QueryFilterHelper> pHelpers;
// there is one table and hence one filter (see constructor)
// Create copy of this filter and use it for quering crossing lines
CopyFilters(out pFilters, out pHelpers);
_filter = pFilters[0];
_filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelCrosses;
_helper = pHelpers[0];
}
private IEnumerable <IRow> SearchNeighborRows([NotNull] IPoint borderConnection,
int neighborPointClassIndex)
{
ISpatialFilter spatialFilter = GetSearchFilter(neighborPointClassIndex,
borderConnection,
_searchDistance);
return(Search(InvolvedTables[neighborPointClassIndex],
spatialFilter,
_filterHelpers[neighborPointClassIndex],
borderConnection));
}
private IEnumerable <IFeature> GetRelatedFeatures([NotNull] IGeometry shape,
int relatedTableIndex)
{
ITable table = InvolvedTables[relatedTableIndex];
ISpatialFilter spatialFilter = _queryFilter[relatedTableIndex];
spatialFilter.Geometry = shape;
QueryFilterHelper filterHelper = _helper[relatedTableIndex];
return(Search(table, spatialFilter, filterHelper).Cast <IFeature>());
}
private ISpatialFilter transformCoordinates(ISpatialFilter inSpatialFilter, ISpatialReference toSpatialReference)
{
ISpatialFilter spOut = new SpatialFilterClass();
spOut.WhereClause = inSpatialFilter.WhereClause;
spOut.SubFields = inSpatialFilter.SubFields;
spOut.SpatialRelDescription = inSpatialFilter.SpatialRelDescription;
spOut.SpatialRel = inSpatialFilter.SpatialRel;
spOut.SearchOrder = inSpatialFilter.SearchOrder;
IEnvelope env = inSpatialFilter.Geometry.Envelope;
env.Project(toSpatialReference);
spOut.Geometry = (IGeometry)env;
return spOut;
}
private void PerformLocationQuery(ISpatialFilter pSpatialFilter)
{
try
{
frmPromptQuerying frmPrompt = new frmPromptQuerying();//��ʾ���ռ��ѯ��
frmPrompt.Show();
System.Windows.Forms.Application.DoEvents();//'ת�ÿ���Ȩ��û����һ��Ļ���ʾ���ڲ���������ʾ
string strLayerName;
IFeatureLayer pFeatureLayer;
IFeatureSelection pFeatureSelection;//������¼��ѯ�Ľ��
foreach (object itemChecked in checkedListBoxFeaturesLayer1.CheckedItems) //����ÿһ��ѡ�еIJ㶼ִ�в�ѯ������ϲ�
{
strLayerName = itemChecked.ToString(); //������Ǵ���ѯ��layer
pFeatureLayer = GetLayerbyName(strLayerName) as IFeatureLayer;
pFeatureSelection = pFeatureLayer as IFeatureSelection;
pFeatureSelection.SelectFeatures(pSpatialFilter, esriSelectionResultEnum.esriSelectionResultAdd, false);//��ѡ�IJ���ܲ�ֹһ��
//ͨ��ѭ�����β�ѯÿ���㣬�ѽ��add����
}
//�����ѡ��ѡ�У���λ��ѡ����
if (checkBoxZoomtoSelected.Checked == true)
{
IEnumFeature pEnumFeature = MainAxMapControl.Map.FeatureSelection as IEnumFeature;
IFeature pFeature = pEnumFeature.Next();
ESRI.ArcGIS.Geometry.IEnvelope pEnvelope = new ESRI.ArcGIS.Geometry.EnvelopeClass();
while (pFeature != null)
{
pEnvelope.Union(pFeature.Extent);
pFeature = pEnumFeature.Next();
}
MainAxMapControl.ActiveView.Extent = pEnvelope;
MainAxMapControl.ActiveView.Refresh();//���������ˢ�£�ֻҪ��ѯǰ��ͼ�Ѿ����Ŵ���Ч���Ļ�����λ��
//��ͼû��ˢ�£�ѡ���Ƕ�λ��ˢ����
}
frmPrompt.Dispose();
//�ѽ����ʾ����
MainAxMapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeoSelection, null, null);
//double i = MainAxMapControl.Map.SelectionCount;
//i = Math.Round(i, 0);//С�����ָ��Ϊ��λ����
//pMainform.toolStripStatusLabel1.Text = "��ǰ����" + i.ToString() + "����ѯ���";
}
catch (Exception ex)
{
MessageBox.Show("���ɲ�ѯ�������!���� | "+ex.Message);
return;
}
}
/// <summary>
/// Fills in the features that need updating
/// </summary>
/// <param name="sFlt">filter</param>
/// <param name="serviceConnection">connection</param>
/// <param name="service">service</param>
/// <param name="lyrID">layerid</param>
/// <returns>any messages from the updating processes</returns>
public string fillDbFtrClasses(ISpatialFilter sFlt, string serviceConnection, string service, Dictionary<string,int> lyrID)
{
esriUtil.Forms.RunningProcess.frmRunningProcessDialog rpd = new esriUtil.Forms.RunningProcess.frmRunningProcessDialog(true);
rpd.showInSepperateProcess();
rpd.Show();
//rpd.addMessage("Downloading data for " + service + " Map Service");
bool lyrTblNeedsUpdating = false;
StringBuilder msg = new StringBuilder();
IWorkspace2 wks2 = (IWorkspace2)servWks;
string svID = getServiceOID(serviceConnection,service);
IAGSServerConnection2 conn = getServiceConnection(serviceConnection);
IAGSServerObjectName3 sobj3 = getServiceObject(conn,service,"MapServer");
IMapServer2 ms2 = getMapService(sobj3);
if (ms2 == null)
{
msg.AppendLine("Could not get map service "+service);
rpd.addMessage("Could not get map service "+service);
updateServiceTable(serviceConnection);
rpd.enableClose();
return msg.ToString();
}
IQueryFilter qryFl = new QueryFilterClass();
string mName = ms2.DefaultMapName;
IWorkspaceEdit wksE = (IWorkspaceEdit)servWks;
bool weEdit = false;
if (!wksE.IsBeingEdited())
{
wksE.StartEditing(false);
weEdit = true;
}
wksE.StartEditOperation();
IFeatureClass ftrCls;
try
{
int stp = 100 / lyrID.Count;
foreach (KeyValuePair<string, int> kvp in lyrID)
{
string lyrName = kvp.Key;
int lyrId = kvp.Value;
if (!checkServerLayer(ms2, lyrId, lyrName))
{
lyrTblNeedsUpdating = true;
msg.AppendLine("Could not find " + lyrName + ". Moving to the next Layer and updating tables.");
continue;
}
else
{
string x = "Updating records for " + lyrName;
rpd.addMessage(x);
rpd.stepPGBar(stp);
msg.AppendLine(x);
}
string ftrClassName = lyrName + "_" + svID + "_" + lyrId.ToString();
string fFtrClassName = geoDatabaseUtility.parsName(ftrClassName);
int drcd = 1;
bool ftrExists = wks2.get_NameExists(esriDatasetType.esriDTFeatureClass, fFtrClassName);
if (!ftrExists)
{
ftrCls = createFtrClass(ms2, lyrId, fFtrClassName);
ISchemaLock sLock = (ISchemaLock)ftrCls;
try
{
sLock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);
IClassSchemaEdit3 cSchEdit3 = (IClassSchemaEdit3)ftrCls;
cSchEdit3.AlterAliasName(lyrName);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
finally
{
sLock.ChangeSchemaLock(esriSchemaLock.esriSharedSchemaLock);
}
}
else
{
ftrCls = fWks.OpenFeatureClass(fFtrClassName);
}
IGeoDataset geoDSet = (IGeoDataset)ftrCls;
ISpatialReference spRf = geoDSet.SpatialReference;
ISpatialReference filtSpRf = sFlt.Geometry.SpatialReference;
if (spRf.FactoryCode != filtSpRf.FactoryCode)
{
rpd.addMessage("Transforming extent from " + filtSpRf.Name + " to " + spRf.Name);
sFlt = transformCoordinates(sFlt, spRf);
}
string oidName = ftrCls.OIDFieldName;
int maxRecords = getMaxRecords(ms2);
List<string> fIdLst = new List<string>();
IFIDSet2 idSet = (IFIDSet2)ms2.QueryFeatureIDs(mName, lyrId, sFlt);
rpd.addMessage("Attempting to download " + idSet.Count().ToString() + " records...");
rpd.Refresh();
idSet.Reset();
IFeatureCursor fCur = ftrCls.Search(sFlt, false);
IFeature ftr = fCur.NextFeature();
while (ftr != null)
{
ftr.Delete();
ftr = fCur.NextFeature();
}
int fId;
int rc = 1;
idSet.Next(out fId);
while (fId > -1)
{
if (drcd > maxRecords)
{
rpd.addMessage("\tDownloading Index " + rc.ToString());
rc+=1;
qryFl.WhereClause = String.Join(" or ", fIdLst.ToArray());
IRecordSet rSet = ms2.QueryFeatureData(mName, lyrId, qryFl);
IFields rFlds = rSet.Fields;
ICursor sCur = rSet.get_Cursor(false);
IRow sRow = sCur.NextRow();
while (sRow != null)
{
fCur = ftrCls.Insert(true);
IFeatureBuffer ftrBuff = ftrCls.CreateFeatureBuffer();
for (int f = 0; f < rFlds.FieldCount; f++)
{
IField rFld = rFlds.get_Field(f);
int fIndex = ftrBuff.Fields.FindField(rFld.Name);
if (fIndex > -1)
{
try
{
ftrBuff.set_Value(fIndex, sRow.get_Value(f));
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
}
fCur.InsertFeature(ftrBuff);
fCur.Flush();
sRow = sCur.NextRow();
}
drcd = 1;
fIdLst.Clear();
}
else
{
fIdLst.Add(oidName + " = '" + fId.ToString() + "'");
drcd += 1;
}
idSet.Next(out fId);
}
if (fIdLst.Count > 0)
{
rpd.addMessage("\tDownloading Index " + rc.ToString());
qryFl.WhereClause = String.Join(" or ", fIdLst.ToArray());
IRecordSet rSet = ms2.QueryFeatureData(mName, lyrId, qryFl);
IFields rFlds = rSet.Fields;
ICursor sCur = rSet.get_Cursor(false);
IRow sRow = sCur.NextRow();
while (sRow != null)
{
fCur = ftrCls.Insert(true);
IFeatureBuffer ftrBuff = ftrCls.CreateFeatureBuffer();
for (int f = 0; f < rFlds.FieldCount; f++)
{
IField rFld = rFlds.get_Field(f);
if (rFld.Editable)
{
int fIndex = ftrBuff.Fields.FindField(rFld.Name);
if (fIndex > -1)
{
try
{
ftrBuff.set_Value(fIndex, sRow.get_Value(f));
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
}
}
fCur.InsertFeature(ftrBuff);
fCur.Flush();
sRow = sCur.NextRow();
}
}
drcd = 1;
fIdLst.Clear();
}
if (lyrTblNeedsUpdating)
{
Dictionary<string,int> dic = getLayers(ms2);
updateLayerTable(dic,serviceConnection, service);
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
finally
{
wksE.StopEditOperation();
if (weEdit)
{
wksE.StopEditing(true);
}
rpd.stepPGBar(100);
rpd.TopMost = false;
rpd.enableClose();
}
return msg.ToString();
}
/// <summary>
/// updates featureclasses that need updatign given a spatial filter
/// </summary>
/// <param name="sFlt">spatial filter</param>
public void getDbFtrClassesThatNeedUpdating(ISpatialFilter sFlt)
{
Dictionary<string, int> lyrId = new Dictionary<string, int>();
Dictionary<int, Dictionary<string, int>> svDic = new Dictionary<int,Dictionary<string,int>>();
IQueryFilter qf = new QueryFilterClass();
try
{
for (int i = 0; i < tblLyr.Fields.FieldCount; i++)
{
IField fld = tblLyr.Fields.get_Field(i);
Console.WriteLine(fld.Name);
}
qf.WhereClause = "\"UPDATE\" = 'YES'";
ICursor SCur = tblLyr.Search(qf, false);
int lyIdIndex, lyIndex, lyFkIndex;
lyIdIndex = tblLyr.FindField("LAYERID");
lyIndex = tblLyr.FindField("LAYERS");
lyFkIndex = tblLyr.FindField("FKID");
IRow sRow = SCur.NextRow();
while (sRow != null)
{
int fkVl = System.Convert.ToInt32(sRow.get_Value(lyFkIndex));
string lyVl = sRow.get_Value(lyIndex).ToString();
int lyIdVl = System.Convert.ToInt32(sRow.get_Value(lyIdIndex));
if (svDic.TryGetValue(fkVl, out lyrId))
{
lyrId.Add(lyVl, lyIdVl);
}
else
{
lyrId = new Dictionary<string, int>();
lyrId.Add(lyVl, lyIdVl);
svDic.Add(fkVl, lyrId);
}
sRow = SCur.NextRow();
}
foreach (KeyValuePair<int, Dictionary<string, int>> kvp in svDic)
{
int svKey = kvp.Key;
lyrId = kvp.Value;
IRow row = tblSrv.GetRow(svKey);
string svName = row.get_Value(row.Fields.FindField("SERVICE")).ToString();
int conFk = System.Convert.ToInt32(row.get_Value(row.Fields.FindField("FKID")));
string svType = row.get_Value(row.Fields.FindField("STYPE")).ToString();
string svUrl = row.get_Value(row.Fields.FindField("URL")).ToString();
row = tblCon.GetRow(conFk);
string cnName = row.get_Value(row.Fields.FindField("CONNECTION")).ToString();
if (svType.ToLower() == "mapserver")
{
fillDbFtrClasses(sFlt, cnName, svName, lyrId);
}
else
{
IImageServerLayer imsLyr = new ImageServerLayerClass();
imsLyr.Initialize(svUrl);
fillDbRaster(imsLyr, sFlt.Geometry.Envelope);
}
}
compactDatabase();
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show(e.ToString());
Console.WriteLine(e.ToString());
}
return ;
}
public bool SetDynamicValues(IObject inObject, string mode, out List<IObject> ChangeFeatureList, out List<IObject> NewFeatureList, out List<IObject> ChangeFeatureGeoList)
{
NumberFormatInfo nfi = new CultureInfo(A4LGSharedFunctions.Localizer.GetString("AA_CultureInfo"), false).NumberFormat;
nfi.NumberGroupSeparator = "";
ChangeFeatureList = null;
NewFeatureList = null;
ChangeFeatureGeoList = null;
IMSegmentation mseg = null;
INetworkFeature netFeat = null;
IJunctionFeature iJuncFeat = null;
IEdgeFeature iEdgeFeat = null;
//ProgressBar
//ESRI.ArcGIS.Framework.IProgressDialogFactory progressDialogFactory = null;
//ESRI.ArcGIS.esriSystem.IStepProgressor stepProgressor = null;
//ESRI.ArcGIS.Framework.IProgressDialog2 progressDialog = null;
//// Create a CancelTracker
//ESRI.ArcGIS.esriSystem.ITrackCancel trackCancel = new ESRI.ArcGIS.Display.CancelTrackerClass();
//trackCancel.CancelOnKeyPress = true;
// trackCancel.CancelOnClick = true;
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14d"));
if (AAState.PerformUpdates == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14a"));
}
if (AAState.PerformUpdates && AAState._dv == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14b") + AAState._defaultsTableName);
AAState.PerformUpdates = false;
return false;
}
if (AAState.PerformUpdates && AAState._dv != null)
{
if (AAState._dv.Table == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14c"));
return false;
}
if (inObject == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14e"));
return false;
}
if (inObject.Table == AAState._tab)
{
if (inObject.get_Value(inObject.Fields.FindField("VALUEMETHOD")).ToString().ToUpper() == "LAST_VALUE")
{
if (inObject.get_Value(inObject.Fields.FindField("FIELDNAME")) != null)
{
if (inObject.get_Value(inObject.Fields.FindField("FIELDNAME")) != DBNull.Value)
{
try
{
LastValueEntry lstVal = AAState.lastValueProperties.GetProperty(inObject.get_Value(inObject.Fields.FindField("FIELDNAME")).ToString()) as LastValueEntry;
if (lstVal != null)
{
lstVal.On_Manual = Globals.toBoolean(inObject.get_Value(inObject.Fields.FindField("ON_MANUAL")).ToString());
lstVal.On_Create = Globals.toBoolean(inObject.get_Value(inObject.Fields.FindField("ON_CREATE")).ToString());
lstVal.On_ChangeAtt = Globals.toBoolean(inObject.get_Value(inObject.Fields.FindField("ON_CHANGE")).ToString());
if (inObject.Fields.FindField("ON_CHANGEGEO") >= 0)
{
lstVal.On_ChangeGeo = Globals.toBoolean(inObject.get_Value(inObject.Fields.FindField("ON_CHANGEGEO")).ToString());
}
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14f"));
}
catch
{
//property does not exist
}
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14g"));
}
return false;
}
string modeVal;
if (AAState._dv.Table.Columns[mode] == null)
{
AAState.WriteLine(mode + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14h"));
mode = mode.Replace("GEO", "");
}
if (AAState._dv.Table.Columns[mode].DataType == System.Type.GetType("System.String"))
{
modeVal = "(" + mode + " = '1' or " + mode + " = 'Yes' or " + mode + " = 'YES' or " + mode + " = 'True' or " + mode + " = 'TRUE')";
}
else
{
modeVal = mode + " = 1";
}
//System.Int32 int32_hWnd = ArcMap.Application.hWnd;
//progressDialogFactory = new ESRI.ArcGIS.Framework.ProgressDialogFactoryClass();
//stepProgressor = progressDialogFactory.Create(trackCancel, int32_hWnd);
//stepProgressor.MinRange = 0;
//stepProgressor.MaxRange = inObject.Fields.FieldCount;
//stepProgressor.StepValue = 1;
//stepProgressor.Message = "Attribute Assistant Progress";
//// Create the ProgressDialog. This automatically displays the dialog
//progressDialog = (ESRI.ArcGIS.Framework.IProgressDialog2)stepProgressor; // Explict Cast
//// Set the properties of the ProgressDialog
//progressDialog.CancelEnabled = true;
ArcMap.Application.StatusBar.set_Message(0, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14i") + inObject.Class.AliasName);
//progressDialog.Description = A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14i") + inObject.Class.AliasName;
//progressDialog.Title = "Attribute Assistant Progress";
//progressDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressGlobe;
//progressDialog.ShowDialog();
//Optional skip junctions feature class
//if (Globals.isOrpanJunction(inFeature))
// return false;
//Get table name for this feature
_currentDataset = inObject.Class as IDataset;
_currentDatasetNameItems = _currentDataset.Name.Split('.');
tableName = _currentDatasetNameItems[_currentDatasetNameItems.GetLength(0) - 1];
ArcMap.Application.StatusBar.set_Message(0, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain10") + inObject.Class.AliasName);
//stepProgressor.Message = A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain10") + inObject.Class.AliasName;
// progressDialog.Description = A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain10") + inObject.Class.AliasName;
AAState.WriteLine("***********************************************************");
AAState.WriteLine("############ " + DateTime.Now + " ################");
AAState.WriteLine("");
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain11"));
if (AAState._dv.Table.Columns.Contains("RUN_WEIGHT"))
AAState._dv.Sort = "RUN_WEIGHT DESC";
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14j") + inObject.Class.AliasName);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14k") + "(TABLENAME = '*' OR TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') AND VALUEMETHOD = 'Last_Value'");
AAState._dv.RowFilter = "(TABLENAME = '*' OR TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') AND VALUEMETHOD = 'Last_Value'";
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14l") + AAState._dv.Count.ToString());
if (AAState._dv.Count > 0)
{
IRowChanges pRowChLast = inObject as IRowChanges;
for (int retRows = 0; retRows < AAState._dv.Count; retRows++)
{
DataRowView drv = AAState._dv[retRows];
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14m") + drv["FIELDNAME"].ToString());
int fldLoc = inObject.Fields.FindField(drv["FIELDNAME"].ToString());
if (fldLoc > 0)
{
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14n") + fldLoc);
if (pRowChLast.get_ValueChanged(fldLoc))
{
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14o") );
try
{
LastValueEntry lstVal = (AAState.lastValueProperties.GetProperty(drv["FIELDNAME"].ToString()) as LastValueEntry);
if (lstVal != null)
{
if (inObject.get_Value(fldLoc) != null)
{
if (inObject.get_Value(fldLoc) != DBNull.Value)
{
if (lstVal.Value != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14p") );
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + ": " + inObject.get_Value(fldLoc).ToString());
lstVal.Value = inObject.get_Value(fldLoc);
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), lstVal);
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14p") );
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + ": " + inObject.get_Value(fldLoc));
lstVal.Value = inObject.get_Value(fldLoc);
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), lstVal);
}
}
else
{
if (mode == "ON_CREATE")
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14q") );
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14p") );
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + ": NULL");
lstVal.Value = null;
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), lstVal);
}
}
}
else
{
if (mode == "ON_CREATE")
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14q") );
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14p") );
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + ": NULL");
lstVal.Value = null;
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), lstVal);
}
}
}
else
{
lstVal = new LastValueEntry();
lstVal.Value = inObject.get_Value(fldLoc);
lstVal.On_Manual = Globals.toBoolean(drv["ON_MANUAL"].ToString());
lstVal.On_Create = Globals.toBoolean(drv["ON_CREATE"].ToString());
lstVal.On_ChangeAtt = Globals.toBoolean(drv["ON_CHANGE"].ToString());
if (drv["ON_CHANGEGEO"] != null)
{
lstVal.On_ChangeGeo = Globals.toBoolean(drv["ON_CHANGEGEO"].ToString());
}
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), lstVal);
}
}
catch
{
}
}
else
{
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14r") );
}
}
}
pRowChLast = null;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14s") + inObject.Class.AliasName);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14k") + "(TABLENAME = '*' OR TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') AND " + modeVal);
AAState._dv.RowFilter = "(TABLENAME = '*' OR TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') AND " + modeVal;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14l") + AAState._dv.Count.ToString());
if (AAState._processCount > 2)
{
System.Threading.Thread.Sleep(400);
}
if (AAState._processCount > 15)
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14t") );
return false;
}
if (AAState._dv.Count > 0)
{
bool proc = false;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14u") );
for (int retRows = 0; retRows < AAState._dv.Count; retRows++)
{
DataRowView drv = AAState._dv[retRows];
AAState.WriteLine(" ------------------------------------------------");
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14v") );
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14w") + (retRows + 1).ToString());
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14x") + drv["TABLENAME"].ToString());
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14y") + drv["FIELDNAME"].ToString());
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14z") + drv["VALUEINFO"].ToString());
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14aa") + drv["VALUEMETHOD"].ToString());
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ab") + drv["ON_CREATE"].ToString());
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ac") + drv["ON_CHANGE"].ToString());
if (AAState._dv.Table.Columns.Contains("RUNORDER"))
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ad") + drv["RUNORDER"].ToString());
AAState.WriteLine("");
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ae") );
valFC = drv["TABLENAME"].ToString().Trim();
if (valFC.Contains("|"))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14af") );
string[] spliVal = valFC.Split('|');
List<string> validSubtypes = new List<string>(spliVal[1].Split(','));
List<string> inValidSubtypes;
if (spliVal.GetLength(0) == 3)
{
inValidSubtypes = new List<string>(spliVal[2].Split(','));
}
else
{
inValidSubtypes = new List<string>();
}
int obSubVal;
ISubtypes pSub = inObject.Class as ISubtypes;
if (pSub != null)
{
if (pSub.HasSubtype)
{
if (inObject.get_Value(pSub.SubtypeFieldIndex).ToString() != "")
{
obSubVal = Convert.ToInt32(inObject.get_Value(pSub.SubtypeFieldIndex).ToString());
if (validSubtypes.Contains("*"))
{
if (inValidSubtypes.Contains(obSubVal.ToString()))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ag") );
proc = false;
continue;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ah") );
}
}
else if (validSubtypes.Contains(obSubVal.ToString()))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ah") );
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ag") );
proc = false;
continue;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ai") );
proc = false;
continue;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14aj") );
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14aj") );
}
}
valMethod = drv["VALUEMETHOD"].ToString().ToUpper().Trim();
valData = drv["VALUEINFO"].ToString().Trim();
if (valData.Contains(Environment.NewLine))
{
valData = valData.Substring(0, valData.IndexOf(Environment.NewLine));
}
List<string> strFldNames = new List<string>();
List<string> strFldAlias = new List<string>();
List<int> intFldIdxs = new List<int>();
fieldObj = null;
if (drv["FIELDNAME"] != null && drv["FIELDNAME"].ToString().Trim() != "" && drv["FIELDNAME"].ToString().Trim() != "*" && drv["FIELDNAME"].ToString().Trim() != "#")
{
strFldNames = new List<string>(drv["FIELDNAME"].ToString().Trim().Split(','));
foreach (string strFldName in strFldNames)
{
if (inObject.Fields.FindField(strFldName) >= 0)
{
strFldAlias.Add(inObject.Fields.get_Field(inObject.Fields.FindField(strFldName)).AliasName);
int tem = inObject.Fields.FindField(strFldName);
intFldIdxs.Add(tem);
fieldObj = inObject.Fields.get_Field(tem);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ak") + inObject.Fields.get_Field(inObject.Fields.FindField(strFldName)).AliasName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14al") + tem);
proc = true;
}
else if (inObject.Fields.FindFieldByAliasName(strFldName) >= 0)
{
int tem = inObject.Fields.FindFieldByAliasName(strFldName);
intFldIdxs.Add(tem);
strFldAlias.Add(inObject.Fields.get_Field(tem).AliasName);
fieldObj = inObject.Fields.get_Field(tem);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ak") + strFldName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14al") + tem);
proc = true;
}
else
{
intFldIdxs.Add(-1);
strFldAlias.Add("{Not Found}");
AAState.WriteLine(" " + strFldName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am") );
fieldObj = null;
proc = false;
}
}
}
else if (drv["FIELDNAME"].ToString() == "#")
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14an") );
IRowChanges pRowCh = null;
IField pTmpFld = null;
pRowCh = inObject as IRowChanges;
for (int i = 0; i < inObject.Fields.FieldCount; i++)
{
pTmpFld = inObject.Fields.get_Field(i);
if (pTmpFld.Type != esriFieldType.esriFieldTypeGlobalID &&
pTmpFld.Type != esriFieldType.esriFieldTypeOID &&
pTmpFld.Type != esriFieldType.esriFieldTypeGeometry &&
pTmpFld.Name.ToUpper() != "SHAPE_LENGTH" &&
pTmpFld.Name.ToUpper() != "SHAPE.LEN" &&
pTmpFld.Name.ToUpper() != "SHAPE_AREA" &&
pTmpFld.Name.ToUpper() != "SHAPE.AREA")
{
if (pRowCh.get_ValueChanged(i) == true)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ao") + pTmpFld.Name + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ap") );
strFldNames.Add(pTmpFld.Name);
intFldIdxs.Add(i);
proc = true;
}
}
}
pRowCh = null;
pTmpFld = null;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14aq") );
fieldObj = null;
proc = true;
}
if (proc)
{
try
{
switch (valMethod)
{
case "FIELD_TRIGGER"://Value|FieldToChange|Value
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "FIELD_TRIGGER" );
if (inFeature != null & valData != null)
{
// Parse arguments
args = valData.Split('|');
string valToCheck = "";
string fldToChange = "";
string valToSet = "";
if (args.GetLength(0) == 3)
{
valToCheck = args[0];
fldToChange = args[1];
valToSet = args[2];
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14av"));
continue;
}
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (intFldIdxs.Count == 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14aw"));
continue;
}
if (intFldIdxs[0] == -1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am"));
continue;
}
if (pRowCh.get_ValueChanged(intFldIdxs[0]))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ax"));
if (inObject.get_Value(intFldIdxs[0]).ToString() == valToCheck)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
int chngFldIdx = Globals.GetFieldIndex(inObject.Fields, fldToChange);
if (chngFldIdx == -1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am"));
continue;
}
try
{
inObject.set_Value(chngFldIdx, valToSet);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14c") + valToSet);
}
}
}
pRowCh = null;
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "FIELD_TRIGGER: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "FIELD_TRIGGER");
}
break;
case "VALIDATE_ATTRIBUTE_LOOKUP":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "VALIDATE_ATTRIBUTE_LOOKUP");
IRowChanges pRowCh = null;
ISQLSyntax sqlSyntax = null;
IQueryFilter pQFilt = null;
try
{
if ((valData != null) && (inObject != null))
{
pRowCh = inObject as IRowChanges;
bool valueChanged = false;
for (int i = 0; i < intFldIdxs.Count; i++)
{
if (pRowCh.get_ValueChanged(intFldIdxs[i]) == true)
{
valueChanged = true;
break;
}
}
if (valueChanged == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain12"));
continue;
}
sourceLayerName = "";
string[] sourceFieldNames = null;
// Parse arguments
args = valData.Split('|');
if (args.Length == 2)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14d"));
continue;
}
if ((sourceFieldNames != null) &&
(sourceFieldNames.Length > 0))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain13") + sourceLayerName);
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
}
IFields pFlds = null;
IDataset pDs = null;
string layNameFnd = "";
bool matchingLayFnd = false;
IStandaloneTable pTbl = null;
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
pFlds = sourceLayer.FeatureClass.Fields;
pDs = sourceLayer.FeatureClass as IDataset;
layNameFnd = sourceLayer.Name;
matchingLayFnd = true;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayerName + " data source is not set");
continue;
}
}
else
{
pTbl = Globals.FindStandAloneTable(AAState._editor.Map, sourceLayerName) as IStandaloneTable;
if (pTbl != null)
{
if (pTbl.Table != null)
{
pFlds = pTbl.Table.Fields;
pDs = pTbl.Table as IDataset;
layNameFnd = pTbl.Name;
matchingLayFnd = true;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayerName + " data source is not set");
continue;
}
}
if (matchingLayFnd == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
continue;
}
sqlSyntax = (ISQLSyntax)(pDs.Workspace);
string specChar = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_WildcardManyMatch);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain14") + layNameFnd + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain15") + sourceLayerName);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain16"));
if (sourceFieldNames.Length != intFldIdxs.Count)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain17"));
continue;
}
int[] sourceFieldNums = new int[sourceFieldNames.Length];
pQFilt = new QueryFilterClass();
string sqlString = "";
string sqlStringUpper = "";
string sqlUpp = "";
if (sqlSyntax.GetStringComparisonCase())
{
sqlUpp = "UPPER";
}
for (int i = 0; i < sourceFieldNames.Length; i++)
{
sourceFieldNums[i] = Globals.GetFieldIndex(pFlds, sourceFieldNames[i].Trim());
if (sourceFieldNums[i] < 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain18") + sourceFieldName[i]);
break;
}
if (pFlds.get_Field(sourceFieldNums[i]).Type == esriFieldType.esriFieldTypeString)
{
if (sqlString == "")
{
sqlString = pFlds.get_Field(sourceFieldNums[i]).Name + "" + " = '" + inObject.get_Value(intFldIdxs[i]).ToString() + "'";
sqlStringUpper = sqlUpp + "(" + pFlds.get_Field(sourceFieldNums[i]).Name + ")" + " LIKE '" + specChar + inObject.get_Value(intFldIdxs[i]).ToString().ToUpper().Replace(" ", specChar) + specChar + "'";
}
else
{
sqlString = sqlString + " AND " + pFlds.get_Field(sourceFieldNums[i]).Name + "" + " = '" + inObject.get_Value(intFldIdxs[i]).ToString() + "'";
sqlStringUpper = sqlStringUpper + " AND " + sqlUpp + "(" + pFlds.get_Field(sourceFieldNums[i]).Name + ")" + " LIKE '" + specChar + inObject.get_Value(intFldIdxs[i]).ToString().ToUpper().Replace(" ", specChar) + specChar + "'";
}
}
else
{
if (sqlString == "")
{
sqlString = pFlds.get_Field(sourceFieldNums[i]).Name + " = " + inObject.get_Value(intFldIdxs[i]);
sqlStringUpper = pFlds.get_Field(sourceFieldNums[i]).Name + " LIKE " + specChar + inObject.get_Value(intFldIdxs[i]) + specChar;
}
else
{
sqlString = sqlString + " AND " + pFlds.get_Field(sourceFieldNums[i]).Name + " = " + inObject.get_Value(intFldIdxs[i]);
sqlStringUpper = sqlStringUpper + " AND " + pFlds.get_Field(sourceFieldNums[i]).Name + " LIKE " + specChar + inObject.get_Value(intFldIdxs[i]) + specChar;
}
}
}
pQFilt.WhereClause = sqlString;
AAState.WriteLine(" " + pQFilt.WhereClause + " used to search for matching record");
int intRecFound = 0;
if (sourceLayer == null)
{
intRecFound = pTbl.Table.RowCount(pQFilt);
}
else
{
intRecFound = sourceLayer.FeatureClass.FeatureCount(pQFilt);
}
AAState.WriteLine(" " + intRecFound + " rows found using " + sqlString);
if (intRecFound != 1)
{
pQFilt.WhereClause = sqlStringUpper;
AAState.WriteLine(" " + pQFilt.WhereClause + " used to search for matching record");
if (sourceLayer == null)
{
intRecFound = pTbl.Table.RowCount(pQFilt);
}
else
{
intRecFound = sourceLayer.FeatureClass.FeatureCount(pQFilt);
}
AAState.WriteLine(" " + intRecFound + " rows found");
if (intRecFound == 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain19"));
AAState._editor.AbortOperation();
return false;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain20"));
ICursor pCurs = null;
if (sourceLayer == null)
{
pCurs = pTbl.Table.Search(pQFilt, true);
}
else
{
pCurs = sourceLayer.FeatureClass.Search(pQFilt, true) as ICursor;
}
pQFilt = null;
List<string> pLst = Globals.CursorToList(ref pCurs, sourceFieldNums);
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
string disFld = "";
for (int j = 0; j < sourceFieldNames.Length - 1; j++)
{
disFld = disFld == "" ? sourceFieldNames[j] : disFld + "|" + sourceFieldNames[j];
}
string selectVal = Globals.showOptionsForm(pLst, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain21") + disFld, ComboBoxStyle.DropDownList);
if (selectVal == "||Cancelled||")
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain19"));
AAState._editor.AbortOperation();
return false;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain22") + selectVal);
string[] strVals = selectVal.Split('|');
for (int i = 0; i < sourceFieldNums.Length; i++)
{
inObject.set_Value(intFldIdxs[i], (strVals[i].Trim()));
}
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain23"));
}
pQFilt = null;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14e") + valData);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14f"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "VALIDATE_ATTRIBUTE_LOOKUP" + Environment.NewLine + ex.Message);
}
finally
{
pQFilt = null;
sqlSyntax = null;
pRowCh = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "VALIDATE_ATTRIBUTE_LOOKUP");
}
break;
}
case "PREVIOUS_VALUE":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "PREVIOUS_VALUE");
IRowChanges pRowCh = null;
try
{
if ((valData != null) && (inObject != null))
{
pRowCh = inObject as IRowChanges;
bool valueChanged = false;
for (int i = 0; i < intFldIdxs.Count; i++)
{
if (pRowCh.get_ValueChanged(intFldIdxs[i]) == true)
{
valueChanged = true;
break;
}
}
if (valueChanged == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain24"));
continue;
}
string[] sourceFieldNames = null;
// Parse arguments
args = valData.Split('|');
if (args.Length == 1)
{
sourceFieldNames = args[0].ToString().Split(',');
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14d"));
continue;
}
if ((sourceFieldNames != null) &&
(sourceFieldNames.Length > 0))
{
int flx = inObject.Fields.FindField(sourceFieldNames[0]);
if (flx > 0)
{
inObject.set_Value(flx, pRowCh.get_OriginalValue(intFldIdxs[0]));
inObject.Store();
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14e") + valData);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14f"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "PREVIOUS_VALUE" + Environment.NewLine + ex.Message);
}
finally
{
pRowCh = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "PREVIOUS_VALUE");
}
break;
}
case "ANGLE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "ANGLE");
if (inFeature != null)
{
if (intFldIdxs.Count == 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain25"));
continue;
}
if ((inFeature.Class as IFeatureClass).ShapeType != esriGeometryType.esriGeometryPolyline)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain26"));
continue;
}
bool boolGeo = true;
if (valData.Trim() != "")
{
if (valData.ToUpper() == "A")
{
boolGeo = false;
}
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain27"));
IPolyline pLyLine = inFeature.Shape as IPolyline;
ILine pLine = new LineClass();
pLine.ToPoint = pLyLine.FromPoint;
pLine.FromPoint = pLyLine.ToPoint;
double angArth = pLine.Angle * 180 / Math.PI;
if (angArth < 0)
{
angArth = 360 + angArth;
}
double angGeo = 270 - angArth;
if (angGeo < 0)
{
angGeo = 360 + angGeo;
}
double ang;
if (boolGeo)
{
ang = angGeo;
}
else
{
ang = angArth;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain28") + ang);
try
{
inObject.set_Value(intFldIdxs[0], ang);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain29"));
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain30"));
}
pLine = null;
pLyLine = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain31"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "ANGLE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "ANGLE");
}
break;
case "CREATE_PERP_LINE"://Layer to Search For|Offset Distante or Field|Search distance to look for a line|UseSnapPoint|TargetLayer|TargetLayerTemplate
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "CREATE_PERP_LINE");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
double offsetVal = 5;
bool useSnapPnt = false;
string targetLayerName = "";
IFeatureLayer targetLayer = null;
string targetLayerTemp = "";
// Parse arguments
args = valData.Split('|');
int fldOff = -1;
if (args.GetLength(0) == 6)
{
sourceLayerNames = args[0].ToString().Split(',');
if (Globals.IsNumeric(args[1]))
Double.TryParse(args[1], out offsetVal);
else
{
fldOff = Globals.GetFieldIndex(inObject.Fields, args[1]);
}
Double.TryParse(args[2], out searchDistance);
Boolean.TryParse(args[3], out useSnapPnt);
targetLayerName = args[4];
targetLayerTemp = args[5];
}
else if (args.GetLength(0) == 5)
{
sourceLayerNames = args[0].ToString().Split(',');
if (Globals.IsNumeric(args[1]))
Double.TryParse(args[1], out offsetVal);
else
{
fldOff = Globals.GetFieldIndex(inObject.Fields, args[1]);
}
Double.TryParse(args[2], out searchDistance);
Boolean.TryParse(args[3], out useSnapPnt);
targetLayerName = args[4];
targetLayerTemp = "";
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14av"));
continue;
}
if (intFldIdxs.Count > 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain32"));
continue;
}
targetLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, targetLayerName, ref boolLayerOrFC);
if (targetLayer == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14g") + targetLayerName);
continue;
}
if (targetLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryPolyline)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14h") + targetLayerName);
continue;
}
if (targetLayer is ICadastralFabricSubLayer2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14i") + targetLayerName);
continue;
}
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
sourceLayerName = args[i].ToString();
if (i == 0)
i++;
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14b") + sourceLayer + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
continue;
}
if (fldOff != -1)
{
try
{
string temp = inObject.get_Value(fldOff).ToString();
if (Globals.IsNumeric(temp))
{
Double.TryParse(temp, out offsetVal);
}
}
catch
{
}
}
IPolyline pTempLine = new PolylineClass();
pTempLine = Globals.CreateAngledLineFromLocationOnLine((IPoint)inFeature.Shape, sourceLayer,
boolLayerOrFC, Globals.ConvertDegToRads(90), offsetVal, "true", true, false);
IEditTemplate pTemp = null;
IFeature pFeat = null;
if (targetLayerTemp != "")
pTemp = Globals.GetEditTemplate(targetLayerTemp, targetLayer);
if (pTemp != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain33"));
pFeat = Globals.CreateFeature(pTempLine, pTemp, AAState._editor, ArcMap.Application, false, false, false);
}
else
{
pFeat = Globals.CreateFeature(pTempLine, targetLayer, AAState._editor, ArcMap.Application, false, false, false);
}
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain34"));
NewFeatureList.Add(pFeat);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "CREATE_PERP_LINE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "CREATE_PERP_LINE");
}
break;
case "AUTONUMBER"://Layer to Search For|Offset Distante or Field|Search distance to look for a line
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "AUTONUMBER");
if (inObject != null)
{
if (intFldIdxs.Count == 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain25"));
continue;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain35") + strFldNames[0]);
string res = Globals.GetFieldStats(inObject.Class as IFeatureClass, strFldNames[0], Globals.statsType.Max);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain36") + res);
if (res == "External component has thrown an exception.")
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain37"));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cm"));
long val = 1;
try
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14co"));
inObject.set_Value(intFldIdxs[0], val);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14j") + ex.Message.ToString());
}
}
else
{
if (Globals.IsNumeric(res))
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cs"));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cr") + res);
try
{
long val = (Convert.ToInt64(res) + 1);
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cq") + res);
try
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14co") + res);
inObject.set_Value(intFldIdxs[0], val);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az") + res);
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14j") + ex.Message.ToString());
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14j") + ex.Message.ToString());
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cp"));
long val = 1;
inObject.set_Value(intFldIdxs[0], val);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cn") + res);
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cm"));
long val = 1;
try
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14co") + res);
inObject.set_Value(intFldIdxs[0], val);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az") + res);
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14j") + ex.Message.ToString());
}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "AUTONUMBER: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "AUTONUMBER");
}
break;
case "COPY_LINKED_RECORD"://Feature Layer|Field To Copy|Primary Key Field|Foreign Key Field
{
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "COPY_LINKED_RECORD");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 4)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
if (inObject == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ak"));
break;
}
string[] targetLayerNames;
string targetFieldName = "";
found = false;
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bs"));
targetLayerNames = args[0].ToString().Split(',');
targetFieldName = args[1].ToString();
string targetLayerName = "";
string sourceIDFieldName = args[2].ToString();
string targetIDFieldName = args[3].ToString();
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bt"));
if (targetFieldName != null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cj"));
int fldIDSourecIdx = Globals.GetFieldIndex(inObject.Fields, sourceIDFieldName);
if (fldIDSourecIdx > -1 && intFldIdxs.Count > 0)
{
if (inObject.get_Value(fldIDSourecIdx) != null && inObject.get_Value(fldIDSourecIdx) != DBNull.Value)
{
if (inObject.get_Value(fldIDSourecIdx).ToString() != "")
{
for (int i = 0; i < targetLayerNames.Length; i++)
{
targetLayerName = targetLayerNames[i].ToString().Trim();
if (targetLayerName != "")
{
// Get layer
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cl"));
bool FCorLayerSource = true;
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, targetLayerName, ref FCorLayerSource);
if (sourceLayer != null)
{
int fldValToCopyIdx = sourceLayer.FeatureClass.Fields.FindField(targetFieldName);
int fldIDTargetIdx = sourceLayer.FeatureClass.Fields.FindField(targetIDFieldName);
if (fldIDTargetIdx > -1 && fldValToCopyIdx > -1)
{
IQueryFilter pQFilt = Globals.createQueryFilter();
if (sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Name + "" + " = '" + inObject.get_Value(fldIDSourecIdx).ToString() + "'";
}
else
{
pQFilt.WhereClause = sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Name + " = " + inObject.get_Value(fldIDSourecIdx);
}
IFeatureCursor pCurs;
pCurs = sourceLayer.FeatureClass.Search(pQFilt, true);
IFeature pRow;
while ((pRow = pCurs.NextFeature()) != null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cf"));
try
{
inObject.set_Value(intFldIdxs[0], pRow.get_Value(fldValToCopyIdx));
break;
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aw") + inObject.get_Value(fldValToCopyIdx) + " to field: " + strFldNames[0]);
}
pRow = null;
}
pRow = null;
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cd"));
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14k"));
}
}
else
{
ITable pTable = Globals.FindTable(AAState._editor.Map, targetLayerName);
if (pTable != null)
{
int fldValToCopyIdx = Globals.GetFieldIndex(pTable.Fields, targetFieldName);
int fldIDTargetIdx = Globals.GetFieldIndex(pTable.Fields, targetIDFieldName);
if (fldIDTargetIdx > -1 && fldValToCopyIdx > -1)
{
IQueryFilter pQFilt = Globals.createQueryFilter();
if (pTable.Fields.get_Field(fldIDTargetIdx).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + pTable.Fields.get_Field(fldIDTargetIdx).Name + "" + " = '" + inObject.get_Value(fldIDSourecIdx).ToString() + "'";
}
else
{
pQFilt.WhereClause = pTable.Fields.get_Field(fldIDTargetIdx).Name + " = " + inObject.get_Value(fldIDSourecIdx);
}
ICursor pCurs;
pCurs = pTable.Search(pQFilt, true);
IRow pRow;
bool valSet = false;
pRow = pCurs.NextRow();
while (pRow != null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cf"));
try
{
inObject.set_Value(intFldIdxs[0], pRow.get_Value(fldValToCopyIdx));
AAState.WriteLine(" " + pRow.get_Value(fldValToCopyIdx).ToString() + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ch"));
valSet = true;
break;
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aw") + inObject.get_Value(fldValToCopyIdx) + " to field: " + strFldNames[0]);
}
pRow = pCurs.NextRow();
}
pRow = null;
if (valSet)
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cd"));
else
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ce"));
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14k"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ax") + sourceLayerName);
}
pTable = null;
}
}
}
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ck"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_LINKED_RECORD" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "COPY_LINKED_RECORD");
}
break;
}
case "UPDATE_LINKED_RECORD"://Feature Layer|Field To Copy|Primary Key Field|Foreign Key Field
{
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "UPDATE_LINKED_RECORD");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 4)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
if (inObject == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ak"));
break;
}
IRowChanges pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == false && mode != "ON_CREATE")
{
AAState.WriteLine(" PROMPT: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ck"));
pRowCh = null;
continue;
}
else
{
pRowCh = null;
string[] targetLayerNames;
string targetFieldName = "";
found = false;
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bs"));
targetLayerNames = args[0].ToString().Split(',');
targetFieldName = args[1].ToString();
string targetLayerName = "";
string sourceIDFieldName = args[2].ToString();
string targetIDFieldName = args[3].ToString();
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bt"));
if (targetFieldName != null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cj"));
int fldIDSourecIdx = Globals.GetFieldIndex(inObject.Fields, sourceIDFieldName);
if (fldIDSourecIdx > -1 && intFldIdxs.Count > 0)
{
if (inObject.get_Value(fldIDSourecIdx) != null && inObject.get_Value(fldIDSourecIdx) != DBNull.Value)
{
if (inObject.get_Value(fldIDSourecIdx).ToString() != "")
{
for (int i = 0; i < targetLayerNames.Length; i++)
{
targetLayerName = targetLayerNames[i].ToString().Trim();
if (targetLayerName != "")
{
// Get layer
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ci"));
bool FCorLayerSource = true;
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, targetLayerName, ref FCorLayerSource);
if (sourceLayer != null)
{
int fldValToCopyIdx = sourceLayer.FeatureClass.Fields.FindField(targetFieldName);
int fldIDTargetIdx = sourceLayer.FeatureClass.Fields.FindField(targetIDFieldName);
if (fldIDTargetIdx > -1 && fldValToCopyIdx > -1)
{
IQueryFilter pQFilt = Globals.createQueryFilter();
if (sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Name + "" + " = '" + inObject.get_Value(fldIDSourecIdx).ToString() + "'";
}
else
{
pQFilt.WhereClause = sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Name + " = " + inObject.get_Value(fldIDSourecIdx);
}
IFeatureCursor pCurs;
pCurs = sourceLayer.FeatureClass.Search(pQFilt, true);
IFeature pRow;
bool valSet = false;
while ((pRow = pCurs.NextFeature()) != null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cg"));
try
{
pRow.set_Value(fldValToCopyIdx, inObject.get_Value(intFldIdxs[0]));
pRow.Store();
AAState.WriteLine(" " + inObject.get_Value(intFldIdxs[0]).ToString() + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ch"));
valSet = true;
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aw") + inObject.get_Value(intFldIdxs[0]).ToString() + " to field: " + targetFieldName);
}
pRow = null;
}
pRow = null;
if (valSet)
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cd"));
else
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ce"));
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14k"));
}
}
else
{
ITable pTable = Globals.FindTable(AAState._editor.Map, targetLayerName);
if (pTable != null)
{
int fldValToCopyIdx = Globals.GetFieldIndex(pTable.Fields, targetFieldName);
int fldIDTargetIdx = Globals.GetFieldIndex(pTable.Fields, targetIDFieldName);
if (fldIDTargetIdx > -1 && fldValToCopyIdx > -1)
{
IQueryFilter pQFilt = Globals.createQueryFilter();
if (pTable.Fields.get_Field(fldIDTargetIdx).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + pTable.Fields.get_Field(fldIDTargetIdx).Name + "" + " = '" + inObject.get_Value(fldIDSourecIdx).ToString() + "'";
}
else
{
pQFilt.WhereClause = pTable.Fields.get_Field(fldIDTargetIdx).Name + " = " + inObject.get_Value(fldIDSourecIdx);
}
ICursor pCurs;
pCurs = pTable.Search(pQFilt, false);
IRow pRow;
bool valSet = false;
pRow = pCurs.NextRow();
while (pRow != null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cf"));
try
{
pRow.set_Value(fldValToCopyIdx, inObject.get_Value(intFldIdxs[0]));
pRow.Store();
AAState.WriteLine(" " + inObject.get_Value(intFldIdxs[0]).ToString() + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ch"));
valSet = true;
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aw") + inObject.get_Value(fldValToCopyIdx) + " to field: " + strFldNames[0]);
}
pRow = pCurs.NextRow();
}
pRow = null;
if (valSet)
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cd"));
else
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ce"));
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14k"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ax") + sourceLayerName);
}
pTable = null;
}
}
}
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ay"));
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "UPDATE_LINKED_RECORD" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "UPDATE_LINKED_RECORD");
}
break;
}
case "OFFSET"://Layer to Search For|Offset Distante or Field|Search distance to look for a line
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "OFFSET");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
double offsetVal = 5;
// Parse arguments
args = valData.Split('|');
int fldOff = -1;
if (args.GetLength(0) >= 3)
{
sourceLayerNames = args[0].ToString().Split(',');
if (Globals.IsNumeric(args[1]))
Double.TryParse(args[1], out offsetVal);
else
{
fldOff = Globals.GetFieldIndex(inObject.Fields, args[1]);
}
Double.TryParse(args[2], out searchDistance);
}
else if (args.GetLength(0) >= 2)
{
sourceLayerNames = args[0].ToString().Split(',');
if (Globals.IsNumeric(args[1]))
Double.TryParse(args[1], out offsetVal);
else
{
fldOff = Globals.GetFieldIndex(inObject.Fields, args[1]);
}
Double.TryParse("1", out searchDistance);
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14av"));
continue;
}
if (intFldIdxs.Count != 2)
{
AAState.WriteLine( A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bn"));
continue;
}
// Get layer
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
sourceLayerName = args[i].ToString();
if (i == 0)
i++;
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14b") + sourceLayer + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
continue;
}
IFeatureClass iFC = inFeature.Class as IFeatureClass;
if (sourceLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayer + " is a polygon layer");
break;
}
if (sourceLayer != null)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
while ((sourceFeature = fCursor.NextFeature()) != null)
{
double dAlong = 0;
if (sourceFeature.Class != inFeature.Class)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
IPoint snapPnt = null;
dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
snapPnt = null;
pIntPnt = null;
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
IPoint snapPnt = null;
dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
snapPnt = null;
pIntPnt = null;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cc") + dAlong);
IPoint pNewPt = new PointClass();
IConstructPoint2 pConsPoint = pNewPt as IConstructPoint2;
if (fldOff != -1)
{
string temp = inObject.get_Value(fldOff).ToString();
if (Globals.IsNumeric(temp))
{
Double.TryParse(temp, out offsetVal);
}
}
pConsPoint.ConstructOffset
(sourceFeature.Shape as ICurve, esriSegmentExtension.esriNoExtension, dAlong, false, offsetVal);
inObject.set_Value(intFldIdxs[0], pNewPt.X);
inObject.set_Value(intFldIdxs[1], pNewPt.Y);
pNewPt = null;
pConsPoint = null;
}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "OFFSET: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "OFFSET");
}
break;
case "SIDE":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "SIDE");
try
{
//Layer|IDField|IDField source
if ((valData != null) && (inFeature != null))
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cb"));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ca") + valData);
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
string inputFieldName = "";
args = valData.Split('|');
if (args.Length < 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "SIDE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bm"));
continue;
}
switch (args.Length)
{
case 3:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
inputFieldName = args[2].ToString();
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "SIDE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bm"));
continue;
}
int fldValToCopyIdx = inObject.Fields.FindField(inputFieldName);
if (fldValToCopyIdx > -1)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
// Get layer
AAState.WriteLine(" " + sourceLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bz"));
int fldValTargetJoinIdx = Globals.GetFieldIndex(sourceLayer, sourceFieldName);
if (fldValTargetJoinIdx > -1)
{
IQueryFilter pQFilt = Globals.createQueryFilter();
if (sourceLayer.FeatureClass.Fields.get_Field(fldValTargetJoinIdx).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + sourceLayer.FeatureClass.Fields.get_Field(fldValTargetJoinIdx).Name + "" + " = '" + inObject.get_Value(fldValToCopyIdx).ToString() + "'";
}
else
{
pQFilt.WhereClause = sourceLayer.FeatureClass.Fields.get_Field(fldValTargetJoinIdx).Name + " = " + inObject.get_Value(fldValToCopyIdx);
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bx") + pQFilt.WhereClause);
int cnt = sourceLayer.FeatureClass.FeatureCount(pQFilt);
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14by") + cnt);
if (cnt > 0)
{
fCursor = sourceLayer.FeatureClass.Search(pQFilt, true);
while ((sourceFeature = fCursor.NextFeature()) != null)
{
bool side = false;
if (Globals.GetPointOnLine(inFeature.Shape, sourceFeature.Shape, 450, out side) != null)
{
if (side)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain38"));
inFeature.set_Value(intFldIdxs[0], "Right");
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain39"));
inFeature.set_Value(intFldIdxs[0], "Left");
}
if (fCursor != null)
Marshal.ReleaseComObject(fCursor);
fCursor = null;
continue;
}
}
if (fCursor != null)
Marshal.ReleaseComObject(fCursor);
fCursor = null;
}
pQFilt = null;
}
}
}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "SIDE" + Environment.NewLine + ex.Message);
}
finally
{
if (fCursor != null)
Marshal.ReleaseComObject(fCursor);
fCursor = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "SIDE");
}
break;
}
case "PROMPT":
{
//Loop through all fields list in the fieldname
//If blank or null, prompt user for value
//Store Value
IDomain pDom = default(IDomain);
ISubtypes pSubType = null;
List<Globals.DomSubList> lst = null;
Globals.DomSubList dmRetVal = null;
try
{
if ((inObject != null))
{
pSubType = (ISubtypes)inObject.Class;
if (pSubType.HasSubtype)
{
int intSub;
if (intFldIdxs.Contains(pSubType.SubtypeFieldIndex))
{
lst = Globals.SubtypeToList(pSubType);
if (inObject.get_Value(pSubType.SubtypeFieldIndex) == null || inObject.get_Value(pSubType.SubtypeFieldIndex) == "" || inObject.get_Value(pSubType.SubtypeFieldIndex) == DBNull.Value)
{
dmRetVal = Globals.showValuesOptionsForm(lst, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + inObject.Class.AliasName + ":" + pSubType.SubtypeFieldName, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + inObject.Class.AliasName + ":" + pSubType.SubtypeFieldName, ComboBoxStyle.DropDownList);
inObject.set_Value(pSubType.SubtypeFieldIndex, dmRetVal.Value);
intSub = Convert.ToInt32(dmRetVal.Value);
}
else
{
intSub = Convert.ToInt32(inObject.get_Value(pSubType.SubtypeFieldIndex));
}
for (int l = 0; l < strFldNames.Count; l++)
{
if (intFldIdxs[l] == pSubType.SubtypeFieldIndex)
continue;
if (intFldIdxs[l] != -1)
{
pDom = pSubType.get_Domain(intSub, inObject.Fields.get_Field(intFldIdxs[l]).Name);
if (pDom == null)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + inObject.Class.AliasName + ":" + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + inObject.Class.AliasName + ":" + strFldAlias[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
else
{
if (pDom is CodedValueDomain)
{
lst = Globals.DomainToList(pDom);
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
dmRetVal = Globals.showValuesOptionsForm(lst, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], ComboBoxStyle.DropDownList);
try
{
inObject.set_Value(intFldIdxs[l], dmRetVal.Value);
}
catch
{
}
lst = null;
}
}
else
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
}
}
else
{
AAState.WriteLine(" PROMPT: " + strFldNames[l] + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
}
else
{
if (inObject.get_Value(pSubType.SubtypeFieldIndex) == null)
intSub = pSubType.DefaultSubtypeCode;
else
intSub = Convert.ToInt32(inObject.get_Value(pSubType.SubtypeFieldIndex));
for (int l = 0; l < strFldNames.Count; l++)
{
if (intFldIdxs[l] != -1)
{
pDom = pSubType.get_Domain(intSub, inObject.Fields.get_Field(intFldIdxs[l]).Name);
if (pDom == null)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
else
{
if (pDom is CodedValueDomain)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
lst = Globals.DomainToList(pDom);
dmRetVal = Globals.showValuesOptionsForm(lst, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], ComboBoxStyle.DropDownList);
try
{
inObject.set_Value(intFldIdxs[l], dmRetVal.Value);
}
catch
{
}
lst = null;
}
}
else
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
}
}
else
{
AAState.WriteLine(" PROMPT: " + strFldNames[l] + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
}
}
else
{
for (int l = 0; l < strFldNames.Count; l++)
{
if (intFldIdxs[l] != -1)
{
pDom = inObject.Fields.get_Field(intFldIdxs[l]).Domain;
if (pDom == null)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
else
{
if (pDom is CodedValueDomain)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
lst = Globals.DomainToList(pDom);
dmRetVal = Globals.showValuesOptionsForm(lst, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], ComboBoxStyle.DropDownList);
try
{
inObject.set_Value(intFldIdxs[l], dmRetVal.Value);
}
catch
{
}
lst = null;
}
}
else
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bw") + strFldAlias[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
}
}
else
{
AAState.WriteLine(" PROMPT: " + strFldNames[l] + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "PROMPT" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "PROMPT");
pDom = null;
pSubType = null;
lst = null;
dmRetVal = null;
}
break;
}
case "CASCADE_ATTRIBUTE":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "CASCADE_ATTRIBUTE");
string flds;
string targetLayer;
IRowChanges pRowCh = null;
try
{
if ((valData != null) && (inObject != null))
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cb"));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ca") + valData);
//field name is the field to Check
//value|Layer|tempalte|Cut or Copy|field-toField
args = valData.Split('|');
if (args.Length < 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "CASCADE_ATTRIBUTE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bl"));
continue;
}
targetLayer = args[0];
flds = args[1];
bool bPrompt;
if (args.Length == 3)
{
if (args[2].ToUpper() == "T" || args[2].ToUpper() == "TRUE" || args[2].ToUpper() == "YES")
{
bPrompt = true;
}
else
{
bPrompt = false;
}
}
else
{
bPrompt = true;
}
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "CASCADE_ATTRIBUTE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bk"));
continue;
}
bool boolFoundAsLayer = true;
sourceLayer = Globals.FindLayer(ArcMap.Application, args[0].ToString(), ref boolFoundAsLayer) as IFeatureLayer;
if (sourceLayer == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "CASCADE_ATTRIBUTE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bj"));
continue;
}
int intTargFld = -1;
intTargFld = sourceLayer.FeatureClass.Fields.FindField(flds);
if (intTargFld == -1)
{
intTargFld = sourceLayer.FeatureClass.Fields.FindFieldByAliasName(flds);
if (intTargFld != -1)
{
flds = sourceLayer.FeatureClass.Fields.get_Field(intTargFld).Name;
}
}
if (intTargFld > -1)
{
bool proceed = true;
if (pRowCh.get_OriginalValue(intFldIdxs[0]).ToString().Trim() == "")
continue;
IQueryFilter pQFilt = new QueryFilterClass();
if (sourceLayer.FeatureClass.Fields.get_Field(intTargFld).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = flds + " = '" + pRowCh.get_OriginalValue(intFldIdxs[0]) + "'";
}
else
{
pQFilt.WhereClause = flds + " = " + pRowCh.get_OriginalValue(intFldIdxs[0]) + "";
}
int featCnt = sourceLayer.FeatureClass.FeatureCount(pQFilt);
if (featCnt == 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain40"));
}
else
{
string promptLayname;
promptLayname = Globals.getClassName(sourceLayer);
if (bPrompt)
{
if (MessageBox.Show("You are about to change " + featCnt + " rows in the " + promptLayname + " Feature Class, proceed?", "Cascade", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain41"));
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain42"));
proceed = false;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain43"));
}
if (proceed)
{
IFeatureCursor pCalcCursor = sourceLayer.FeatureClass.Update(pQFilt, false);
IFeature updateFeat;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
while ((updateFeat = pCalcCursor.NextFeature()) != null)
{
updateFeat.set_Value(intTargFld, inObject.get_Value(intFldIdxs[0]));
ChangeFeatureList.Add(updateFeat);
//if (!trackCancel.Continue())
//{
// AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain19"));
// AAState._editor.AbortOperation();
// return false;
//}
}
updateFeat = null;
if (pCalcCursor != null)
{
Marshal.ReleaseComObject(pCalcCursor);
}
pCalcCursor = null;
pQFilt = null;
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "CASCADE_ATTRIBUTE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bi"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "CASCADE_ATTRIBUTE" + Environment.NewLine + ex.Message);
}
finally
{
sourceLayer = null;
pRowCh = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "CASCADE_ATTRIBUTE");
}
break;
}
case "COPY_FEATURE":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "COPY_FEATURE");
IFeatureLayer pTargetFL;
string[] FldPairs;
string targetValue;
IRowChanges pRowCh = null;
IFeature pNewFeat = null;
try
{
if ((valData != null) && (inFeature != null))
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cb"));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ca") + valData);
//field name is the field to Check
//value|Layer|tempalte|Cut or Copy|field-toField
args = valData.Split('|');
if (args.Length < 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_FEATURE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bh"));
continue;
}
targetValue = args[0];
pRowCh = inObject as IRowChanges;
if (intFldIdxs.Count > 0)
{
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == false && mode != "ON_CREATE")
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain44"));
continue;
}
if (inFeature.get_Value(intFldIdxs[0]).ToString() != targetValue.ToString())
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain45"));
continue;
}
}
bool FCorLayerTarget = true;
pTargetFL = Globals.FindLayer(ArcMap.Application, args[1].ToString(), ref FCorLayerTarget) as IFeatureLayer;
if (pTargetFL == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_FEATURE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bg"));
continue;
}
if (Globals.IsEditable(ref pTargetFL, ref AAState._editor) == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_FEATURE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14be"));
continue;
}
if (pTargetFL.FeatureClass.ShapeType != (inFeature.Class as IFeatureClass).ShapeType)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_FEATURE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bf"));
continue;
}
FldPairs = null;
//value|Layer|tempalte|Cut or Copy|field-toField
IEditTemplate pEditTemp = null;
string sourceAction = "COPY";
string fldMatching = null;
switch (args.Length)
{
//case 2:
// break;
case 3:
if (args[2].Trim() != "")
{
pEditTemp = Globals.PromptAndGetEditTemplateGraphic(pTargetFL, args[2].Trim());
}
else
{
pEditTemp = null;
}
break;
case 4:
if (args[2].Trim() != "")
{
pEditTemp = Globals.PromptAndGetEditTemplateGraphic(pTargetFL, args[2].Trim());
}
else
{
pEditTemp = null;
}
sourceAction = args[3].ToUpper().Trim();
break;
case 5:
if (args[2].Trim() != "")
{
pEditTemp = Globals.PromptAndGetEditTemplateGraphic(pTargetFL, args[2].Trim());
}
else
{
pEditTemp = null;
}
sourceAction = args[3].ToUpper().Trim();
fldMatching = args[4].Trim();
break;
}
if (pEditTemp != null)
{
pNewFeat = Globals.CreateFeature(inFeature.ShapeCopy, pEditTemp, AAState._editor, ArcMap.Application, false, false, false);
}
else
{
pNewFeat = Globals.CreateFeature(inFeature.ShapeCopy, pTargetFL, AAState._editor, ArcMap.Application, false, false, false);
}
pEditTemp = null;
if (fldMatching != null)
{
if (fldMatching == "")
{
FldPairs = new string[] { };
}
else
{
FldPairs = fldMatching.Split(',');
}
}
else
{
FldPairs = new string[] { };
}
List<string> targFilds = new List<string>();
foreach (string strFlpPair in FldPairs)
{
string[] fldMatch = strFlpPair.Split('-');
if (fldMatch.Length != 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_FEATURE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bd"));
}
else
{
string strSrcFldName = fldMatch[0];
string strTarFldName = fldMatch[1];
int intSrcFldIdx = Globals.GetFieldIndex((inFeature.Class as IFeatureClass).Fields, (strSrcFldName));
int intTarFldIdx = Globals.GetFieldIndex(pTargetFL.FeatureClass.Fields, strTarFldName);
if (intSrcFldIdx == -1 || intTarFldIdx == -1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_FEATURE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bc"));
}
else
{
targFilds.Add(strTarFldName.ToUpper());
try
{
pNewFeat.set_Value(intTarFldIdx, inFeature.get_Value(intSrcFldIdx));
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_FEATURE: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14bb") + strFlpPair);
}
}
}
}
IFields pTarFields = pTargetFL.FeatureClass.Fields;
IField pTarField = null;
for (int i = 0; i < pTarFields.FieldCount; i++)
{
pTarField = pTarFields.get_Field(i);
if (pTarField.Type != esriFieldType.esriFieldTypeGlobalID &&
pTarField.Type != esriFieldType.esriFieldTypeOID &&
pTarField.Type != esriFieldType.esriFieldTypeGeometry &&
pTarField.Name.ToUpper() != "SHAPE_LENGTH" &&
pTarField.Name.ToUpper() != "SHAPE.LEN" &&
pTarField.Name.ToUpper() != "SHAPE_AREA" &&
pTarField.Name.ToUpper() != "SHAPE.AREA")
{
if (targFilds.Contains(pTarField.Name.ToUpper()) == false)
{
int fldIdx = inFeature.Fields.FindField(pTarField.Name);
if (fldIdx > 0)
{
try
{
pNewFeat.set_Value(i, inFeature.get_Value(fldIdx));
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain46") + pTarField.Name);
}
}
}
}
}
pTarFields = null;
pTarField = null;
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
NewFeatureList.Add(pNewFeat);
if (sourceAction == "CUT")
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain47"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain48"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "COPY_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
pTargetFL = null;
pRowCh = null;
pNewFeat = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "COPY_FEATURE");
}
break;
}
case "VALIDATE_CONNECTIVITY":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "VALIDATE_CONNECTIVITY");
try
{
if ((valData != null) && (inFeature != null))
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cb"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain49"));
bool validFeat = false;
if (inFeature is INetworkFeature)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain50"));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ca") + valData);
args = valData.Split('|');
int connectionCnt = Globals.getConnectionCount(inFeature);
foreach (string fldConPair in args)
{
string[] fldCon = fldConPair.Split(',');
if (fldCon.Length == 1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain51"));
if (Globals.IsNumeric(fldCon[0]))
{
if (connectionCnt == Convert.ToInt32(fldCon[0]))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain52"));
validFeat = true;
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain53"));
}
}
else
{
if (intFldIdxs.Count == 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain51"));
if (fldCon.Length == 2)
{
if (connectionCnt == Convert.ToInt32(fldCon[1]))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain52"));
validFeat = true;
break;
}
}
if (fldCon.Length > 2)
{
if (connectionCnt >= Convert.ToInt32(fldCon[1]) && connectionCnt <= Convert.ToInt32(fldCon[2]))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain52"));
validFeat = true;
break;
}
}
}
else if (inFeature.get_Value(intFldIdxs[0]).ToString() == fldCon[0])
{
if (fldCon.Length == 2)
{
if (connectionCnt == Convert.ToInt32(fldCon[1]))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain52"));
validFeat = true;
break;
}
}
if (fldCon.Length > 2)
{
if (connectionCnt >= Convert.ToInt32(fldCon[1]) && connectionCnt <= Convert.ToInt32(fldCon[2]))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain52"));
validFeat = true;
break;
}
}
}
}
}
if (validFeat == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain19"));
AAState._editor.AbortOperation();
return false;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain54"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain48"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "VALIDATE_CONNECTIVITY" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "VALIDATE_CONNECTIVITY");
}
break;
}
case "VALIDATE_ATTRIBUTES":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "VALIDATE_ATTRIBUTES");
try
{
if ((valData != null) && (inFeature != null))
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14cb"));
IRowChanges pRowCh = inObject as IRowChanges;
changed = true;
if (intFldIdxs != null && intFldIdxs.Count > 0 && mode != "ON_CREATE")
{
for (int fldIdx = 0; fldIdx < intFldIdxs.Count; fldIdx++)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain55"));
changed = pRowCh.get_ValueChanged(intFldIdxs[fldIdx]);
AAState.WriteLine(" " + strFldNames[fldIdx] + " changed value was " + changed);
if (changed)
break;
}
}
if (changed)
{
args = valData.Split('|');
args = args[0].Split(',');
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain56") + args);
if (args.Length > 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain57"));
IList<ILayer> pLayList = Globals.FindLayersByClassID(((IMxDocument)ArcMap.Application.Document).FocusMap, inObject.Class.ObjectClassID);
if (pLayList != null)
{
if (pLayList.Count > 0)
{
AAState.WriteLine(" " + pLayList.Count + " Layers found");
bool ValidComb = false;
foreach (ILayer pLay in pLayList)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain58") + pLay.Name);
if (pLay is IFeatureLayer)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain59"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain60"));
IEditTemplateManager pEdTmpManager = Globals.GetEditTemplateManager((IFeatureLayer)pLay);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain61"));
ValidComb = Globals.FeatureIsValidTemplate(pEdTmpManager, inFeature, args);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain62") + ValidComb.ToString());
if (ValidComb == true)
break;
}
}
if (ValidComb == false)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain19"));
AAState._editor.AbortOperation();
return false;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain63"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain63"));
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain64"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "VALIDATE_ATTRIBUTES" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "VALIDATE_ATTRIBUTES");
}
break;
}
case "SPLIT_INTERSECTING_FEATURE":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "SPLIT_INTERSECTING_FEATURE");
try
{
if ((valData != null) && (inFeature != null))
{
intersectLayerName = "";
intersectLayer = null;
args = valData.Split('|');
if (args.Length > 0)
{
AAState.WriteLine(" " + args.Length + " Layers listed ");
for (int i = 0; i < args.Length; i++)
{
intersectLayerName = args[i].Trim();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain65") + intersectLayerName);
boolLayerOrFC = true;
if (intersectLayerName.Contains("("))
{
string[] tempSplt = intersectLayerName.Split('(');
intersectLayerName = tempSplt[0];
intersectLayer = Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC) as IFeatureLayer;
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
intersectLayer = Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC) as IFeatureLayer;
}
if (intersectLayer != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain66") + intersectLayerName);
if (intersectLayer.FeatureClass != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain67") + intersectLayerName);
double snapTol = Globals.GetXYTolerance(intersectLayer);
sFilter = Globals.createSpatialFilter(intersectLayer, inFeature, false);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain68"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain69") + intersectLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain70"));
pFS = (IFeatureSelection)intersectLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = intersectLayer.Search(sFilter, true);
}
}
else
{
fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
}
IFeature intsersectFeature;
int idx = 1;
while ((intsersectFeature = fCursor.NextFeature()) != null)
{
if (intsersectFeature.Class != inFeature.Class)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain71") + idx);
idx++;
if (intsersectFeature is INetworkFeature)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain72"));
}
else
{
ISet featset = Globals.splitLineWithPoint(intsersectFeature, inFeature.ShapeCopy as IPoint, snapTol, null, "{0:0.00}", ArcMap.Application);
if (featset != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain73"));
if (featset.Count > 0)
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
object featobj;
while ((featobj = featset.Next()) != null)
{
IFeature feature = featobj as IFeature;
if (feature != null)
{
NewFeatureList.Add(feature as IObject);
}
feature = null;
}
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain74") + intersectLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain75") + featset.Count);
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain76"));
}
featset = null;
}
}
if (intsersectFeature != null)
{
Marshal.ReleaseComObject(intsersectFeature);
}
else if (intsersectFeature.Class == inFeature.Class && intsersectFeature.OID != inFeature.OID)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain71") + idx);
idx++;
if (intsersectFeature is INetworkFeature)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain72"));
}
else
{
ISet featset = Globals.splitLineWithPoint(intsersectFeature, inFeature.ShapeCopy as IPoint, snapTol, null, "{0:0.00}", ArcMap.Application);
if (featset == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain77"));
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain73"));
if (featset.Count > 0)
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
object featobj;
while ((featobj = featset.Next()) != null)
{
IFeature feature = featobj as IFeature;
if (feature != null)
{
NewFeatureList.Add(feature as IObject);
}
feature = null;
}
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain74") + intersectLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain75") + featset.Count);
}
featset = null;
}
if (intsersectFeature != null)
{
Marshal.ReleaseComObject(intsersectFeature);
}
}
}
intsersectFeature = null;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain78") + intersectLayerName);
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14l") + valData);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14m"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "SPLIT_INTERSECTING_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "SPLIT_INTERSECTING_FEATURE");
}
break;
}
case "NEAREST_FEATURE_ATTRIBUTES":
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "NEAREST_FEATURE_ATTRIBUTES");
try
{
if ((valData != null) && (inFeature != null))
{
sourceLayerName = "";
string[] sourceFieldNames = null;
string[] destFieldNames = null;
searchDistance = 0;
// Parse arguments
args = valData.Split('|');
if (args.Length == 3)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
destFieldNames = args[2].ToString().Split(',');
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain79"));
}
else if (args.Length == 4)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
destFieldNames = args[2].ToString().Split(',');
Double.TryParse(args[3], out searchDistance);
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14d"));
continue;
}
if ((sourceFieldNames != null) && (destFieldNames != null) &&
(sourceFieldNames.Length > 0) && (destFieldNames.Length > 0) &&
(sourceFieldNames.Length == destFieldNames.Length))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain13") + sourceLayerName);
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
}
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
AAState.WriteLine(" " + sourceLayer.Name + " layer Found: " + sourceLayerName);
string missingFieldMess = null;
int[] sourceFieldNums = new int[sourceFieldNames.Length];
int[] destFieldNums = new int[destFieldNames.Length];
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain80"));
for (int i = 0; i < sourceFieldNums.Length; i++)
{
int fnum = sourceLayer.FeatureClass.FindField(sourceFieldNames[i].Trim());
if (fnum < 0)
{
missingFieldMess = sourceFieldNames[i].Trim() + " in table " + sourceLayerName;
break;
}
sourceFieldNums[i] = fnum;
}
if (missingFieldMess == null)
{
for (int i = 0; i < destFieldNums.Length; i++)
{
int fnum = inFeature.Fields.FindField(destFieldNames[i].Trim());
if (fnum < 0)
{
missingFieldMess = destFieldNames[i].Trim() + " in table " + tableName;
break;
}
destFieldNums[i] = fnum;
}
}
if (missingFieldMess == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain81"));
// found source and destination fields.
if (searchDistance > 0)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
}
else
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain82"));
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, false, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, false);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, false);
}
sourceFeature = fCursor.NextFeature();
nearestFeature = null;
proxOp = (IProximityOperator)inFeature.Shape;
lastDistance = searchDistance;
if (sourceFeature != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain83"));
while (sourceFeature != null)
{
if (sourceFeature.Class != inFeature.Class)
{
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
sourceFeature = fCursor.NextFeature();
}
}
if (nearestFeature != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain84") + lastDistance + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain85") + nearestFeature.OID);
for (int i = 0; i < sourceFieldNums.Length; i++)
{
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain86") + sourceFieldNames[i] + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain87") + destFieldNames[i]);
inObject.set_Value(destFieldNums[i], nearestFeature.get_Value(sourceFieldNums[i]));
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14n") + sourceFieldNames[i] + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain87") + destFieldNames[i]);
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain88"));
for (int i = 0; i < destFieldNums.Length; i++)
{
IField field = inObject.Fields.get_Field(destFieldNums[i]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(destFieldNums[i], null);
}
}
else
{
inObject.set_Value(destFieldNums[i], newval);
}
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14o") + missingFieldMess);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayerName + " data source is not set");
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14e") + valData);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14f"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "NEAREST_FEATURE_ATTRIBUTES" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "NEAREST_FEATURE_ATTRIBUTES");
}
break;
}
case "MINIMUM_LENGTH":
{
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "MINIMUM_LENGTH");
double minlength;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain89"));
if (Double.TryParse(valData, out minlength))
{
if (inFeature != null)
{
ICurve curve = inFeature.Shape as ICurve;
if (curve != null)
{
if (curve.Length < minlength)
{
String mess = "Line is shorter than " +
String.Format("{0:0.00}", minlength) + " " + Globals.GetSpatRefUnitName(inFeature.Shape.SpatialReference, true) +
", aborting edit.";
AAState.WriteLine(" " + mess);
MessageBox.Show(mess, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain90"));
AAState._editor.AbortOperation();
return false;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14p"));
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "MINIMUM_LENGTH \n" + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "MINIMUM_LENGTH");
}
break;
}
case "LINK_TABLE_ASSET":
try
{
intersectLayerName = "";
intersectTable = null;
intersectLayer = null;
List<string> intersectLayerFieldNameList = new List<string>();
List<int> intersectFieldPosList = new List<int>();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "LINK_TABLE_ASSET");
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // Feature Layer only
intersectLayerName = args[0].ToString();
break;
case 2: // Feature Layer| Field to copy
intersectLayerName = args[0].ToString();
intersectLayerFieldNameList = new List<string>(args[1].ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
break;
case 3: // Feature Layer| Field to copy | for future
intersectLayerName = args[0].ToString();
intersectLayerFieldNameList = new List<string>(args[1].ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14q") + valData);
continue;
}
bool FCorLayerIntersect = true;
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref FCorLayerIntersect);
intersectTable = Globals.FindStandAloneTable(AAState._editor.Map, intersectLayerName);
if (intersectLayer != null)
{
//Find Area Field
foreach (string intersectLayerFieldName in intersectLayerFieldNameList)
{
intersectFieldPos = intersectLayer.FeatureClass.Fields.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14r") +"(" + intersectLayerFieldName + ") not found");
break;
}
else
{
intersectFieldPosList.Add(intersectFieldPos);
}
}
intersectLayerSelection = (IFeatureSelection)intersectLayer;
if (intersectLayerSelection.SelectionSet.Count == 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14s") + intersectLayerName);
break;
}
if (intersectLayerSelection.SelectionSet.Count > 1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14t") + intersectLayerName);
break;
}
intersectLayerSelection.SelectionSet.Search(null, true, out cCurs);
}
else if (intersectTable != null)
{
if (intersectTable.Table == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14u") + "(" + intersectLayerName + ") not found");
break;
}
foreach (string intersectLayerFieldName in intersectLayerFieldNameList)
{
intersectFieldPos = intersectTable.Table.Fields.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14v") + "(" + intersectLayerFieldName + ") not found");
break;
}
else
{
intersectFieldPosList.Add(intersectFieldPos);
}
}
intersectTableSelection = (ITableSelection)intersectTable;
if (intersectTableSelection.SelectionSet.Count == 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14s") + intersectLayerName);
break;
}
if (intersectTableSelection.SelectionSet.Count > 1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14t") + intersectLayerName);
break;
}
intersectTableSelection.SelectionSet.Search(null, true, out cCurs);
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14u") + "(" + intersectLayerName + ") not found");
break;
}
IRow row;
while ((row = cCurs.NextRow()) != null)
{
int idx = 0;
foreach (int fldIdxInt in intersectFieldPosList)
{
if (idx >= intFldIdxs.Count)
continue;
string val = row.get_Value(fldIdxInt).ToString();
if (inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(intFldIdxs[idx], val);
else if (inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeSmallInteger || inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeInteger)
{
if (Globals.IsNumeric(val))
{
inObject.set_Value(intFldIdxs[idx], Convert.ToInt32(val));
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14w") + val);
}
}
else if (inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeSingle || inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeDouble)
{
if (Globals.IsNumeric(val))
{
inObject.set_Value(intFldIdxs[idx], Convert.ToDouble(val));
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14x") + val);
}
}
else
{
inObject.set_Value(intFldIdxs[idx], val);
}
idx++;
}
}
if (row != null)
Marshal.ReleaseComObject(cCurs);
row = null;
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "LINK_TABLE_ASSET" + Environment.NewLine + ex.Message);
}
finally
{
if (cCurs != null)
{
Marshal.ReleaseComObject(cCurs);
GC.Collect(300);
GC.WaitForFullGCComplete();
cCurs = null;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "LINK_TABLE_ASSET");
}
break;
case "GET_ADDRESS_FROM_CENTERLINE":
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "GET_ADDRESS_FROM_CENTERLINE");
List<IPoint> pPnts = null;
try
{
if ((valData != null) && (inFeature != null))
{
sourceLayerName = "";
string[] sourceFieldNames = null;
searchDistance = 0;
// Parse arguments
args = valData.Split('|');
if (args.Length == 2)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
searchDistance = 2;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain79"));
}
else if (args.Length == 3)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
Double.TryParse(args[2], out searchDistance);
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14d"));
continue;
}
if (sourceFieldNames.Length != 5)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14y"));
continue;
}
boolLayerOrFC = false;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
pPnts = Globals.GetGeomCenter(inObject as IFeature);
if (pPnts.Count != 0)
{
AddressInfo pRetValu = Globals.GetAddressInfo(ArcMap.Application, pPnts[0] as IPoint, sourceLayerName,
sourceFieldNames[0].Trim(), sourceFieldNames[1].Trim(), sourceFieldNames[2].Trim(), sourceFieldNames[3].Trim(), sourceFieldNames[4].Trim(), false, searchDistance);
if (pRetValu != null)
{
if (pRetValu.Messages == "")
{
bool rightSide = true;
IPoint pPnt = Globals.GetPointOnLine((inObject as IFeature).Shape as IPoint, pRetValu.StreetGeometry as IPolyline, 400, out rightSide);
try
{
if (strFldNames.Count == 2)
{
if (intFldIdxs[0] != -1)
{
if (rightSide)
{
inObject.set_Value(intFldIdxs[0], pRetValu.RightAddress);
}
else
{
inObject.set_Value(intFldIdxs[0], pRetValu.LeftAddress);
}
}
if (intFldIdxs[1] != -1)
inObject.set_Value(intFldIdxs[1], pRetValu.StreetName);
}
else
{
if (intFldIdxs[0] != -1)
{
if (rightSide)
{
inObject.set_Value(intFldIdxs[0], pRetValu.RightAddress + " " + pRetValu.StreetName);
}
else
{
inObject.set_Value(intFldIdxs[0], pRetValu.LeftAddress + " " + pRetValu.StreetName);
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14z") + Environment.NewLine + ex.Message);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aa") + pRetValu.Messages);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ab"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ac"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GET_ADDRESS_FROM_CENTERLINE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "GET_ADDRESS_FROM_CENTERLINE");
pPnts = null;
}
break;
case "GET_ADDRESS_USING_GEOCODER":
{
IReverseGeocoding reverseGeocoding = null;
IAddressGeocoding addressGeocoding = null;
IPoint revGCLoc = null;
IFields matchFields = null;
IField shapeField = null;
IReverseGeocodingProperties reverseGeocodingProperties = null;
IPropertySet addressProperties = null;
IAddressInputs addressInputs = null;
IFields addressFields = null;
object key = null;
object value = null;
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "GET_ADDRESS_USING_GEOCODER");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain91"));
reverseGeocoding = Globals.OpenLocator(args[0], args[1]);
if (reverseGeocoding == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ae"));
break;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain92"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain93"));
revGCLoc = Globals.GetGeomCenter(inFeature)[0];
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain94"));
// Create a Point at which to find the address.
addressGeocoding = (IAddressGeocoding)reverseGeocoding;
matchFields = addressGeocoding.MatchFields;
int shpFld = matchFields.FindField("Shape");
shapeField = matchFields.get_Field(shpFld);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain95"));
// Set the search tolerance for reverse geocoding.
reverseGeocodingProperties = (IReverseGeocodingProperties)reverseGeocoding;
reverseGeocodingProperties.SearchDistance = 100;
reverseGeocodingProperties.SearchDistanceUnits = esriUnits.esriFeet;
reverseGeocoding.InitDefaults();
// Find the address nearest the Point.
addressProperties = reverseGeocoding.ReverseGeocode(revGCLoc, false);
// Print the address properties.
addressInputs = (IAddressInputs)reverseGeocoding;
addressFields = addressInputs.AddressFields;
addressProperties.GetAllProperties(out key, out value);
string tempVal = "";
for (int i = 0; i < addressFields.FieldCount; i++)
{
IField addressField = addressFields.get_Field(i);
if (tempVal == "")
{
tempVal = addressProperties.GetProperty(addressField.Name).ToString();
}
else
{
tempVal = tempVal + ", " + addressProperties.GetProperty(addressField.Name).ToString();
}
}
inFeature.set_Value(intFldIdxs[0], tempVal);
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GET_ADDRESS_USING_GEOCODER" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "GET_ADDRESS_USING_GEOCODER");
reverseGeocoding = null;
addressGeocoding = null;
revGCLoc = null;
matchFields = null;
shapeField = null;
reverseGeocodingProperties = null;
addressProperties = null;
addressInputs = null;
addressFields = null;
key = null;
value = null;
}
break;
}
case "GET_ADDRESS_USING_ARCGIS_SERVICE": //ARGS: url
try
{
IPoint revGCLoc = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "GET_ADDRESS_USING_ARCGIS_SERVICE");
if (fieldObj.Type == esriFieldType.esriFieldTypeString)
{
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
args = valData.Split('|');
revGCLoc = Globals.GetGeomCenter(inFeature)[0];
int wkid = inFeature.Shape.SpatialReference.FactoryCode;
if (revGCLoc != null)
{
//Test for user specified URL
if (valData.Trim() != "")
{
if (args.Length == 2)
{
wkid = Convert.ToInt32(args[1]);
}
if (Globals.IsUrl(args[0]))
{
locatorURL = args[0];
if (!(locatorURL.EndsWith(reverseGeocodeStr)))
{
if (!(locatorURL.EndsWith(GeocodeStr)))
{
if (!(locatorURL.EndsWith("/")))
{
locatorURL += "/" + GeocodeStr + "/" + reverseGeocodeStr;
}
else
{
locatorURL += GeocodeStr + "/" + reverseGeocodeStr;
}
}
else
{
if (!(locatorURL.EndsWith("/")))
{
locatorURL += "/" + reverseGeocodeStr;
}
else
{
locatorURL += reverseGeocodeStr;
}
}
}
}
//else if (args[0] == "TA_Streets_US_10")
//{
// locatorURL = _agsOnlineLocators + args[0] + GeocodeStr + "/" + reverseGeocodeStr;
// // wkid = 102100;
//}
//else if (args[0] == "TA_Address_NA_10" || args[0] == "TA_Address_EU")
//{
// locatorURL = _agsOnlineLocators + args[0] + GeocodeStr + "/" + reverseGeocodeStr;
// // wkid = 4326;
//}
////Default to AGS Online USA geocode service
//else if (_agsOnlineLocators.Substring(_agsOnlineLocators.LastIndexOf('/', _agsOnlineLocators.Length - 2)).Contains("Locator"))
//{
// locatorURL = _agsOnlineLocators + "TA_Address_NA_10" + GeocodeStr + "/" + reverseGeocodeStr;
// // wkid = 4326;
//}
else
{
locatorURL = _agsOnlineLocators + GeocodeStr + "/" + reverseGeocodeStr; ;
// wkid = 4326;
}
}
else
{
if (_agsOnlineLocators.Substring(_agsOnlineLocators.LastIndexOf('/', _agsOnlineLocators.Length - 2)).Contains(GeocodeStr))
{
locatorURL = _agsOnlineLocators + "/" + reverseGeocodeStr;
// wkid = 4326;
}
else
{
_agsOnlineLocators = _agsOnlineLocators + "/" + GeocodeStr;
locatorURL = _agsOnlineLocators + "/" + reverseGeocodeStr;
// wkid = 4326;
}
}
if (!locatorURL.ToUpper().Contains("/REST/"))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14af"));
}
else
{
//Copy point from this current feature
_copyPoint = revGCLoc;//inFeature.ShapeCopy as IPoint;
StreamReader reader = null;
HttpWebRequest request = null;
try
{
// Create the web request
request = WebRequest.Create(_agsOnlineLocators) as HttpWebRequest;
// Get response
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
// Get the response stream
reader = new StreamReader(response.GetResponseStream());
string resp = reader.ReadToEnd();
resp = resp.Substring(resp.IndexOf("Spatial Reference:"));
resp = resp.Substring(0, resp.IndexOf("<br/>"));
resp = resp.Substring(resp.IndexOf("</b>") + 4);
wkid = Convert.ToInt32(resp.Split(' ')[0]);
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain96"));
wkid = 4326;
}
finally
{
reader = null;
request = null;
}
_copyPoint.Project(Globals.CreateSpatRef(wkid));
//Include location parameters in URL
string results = Globals.FormatLocationRequest(locatorURL, _copyPoint.X, _copyPoint.Y, 100);
//Send and receieve the request
WebRequest req = null;
WebResponse res = null;
XmlDictionaryReader xr = null;
XmlDocument doc = null;
try
{
req = WebRequest.Create(results);
res = req.GetResponse();
//Convert response from JSON to XML
doc = new XmlDocument();
using (Stream s = res.GetResponseStream())
{
xr = JsonReaderWriterFactory.CreateJsonReader(s, XmlDictionaryReaderQuotas.Max);
doc.Load(xr);
xr.Close();
s.Close();
string val = "";
for (int h = 0; h < doc.DocumentElement.FirstChild.ChildNodes.Count - 1; h++)
{
if (doc.DocumentElement.FirstChild.ChildNodes[h].Name.Contains("Match") == false)
{
if (val == "")
{
val = doc.DocumentElement.FirstChild.ChildNodes[h].InnerText;
}
else
{
if (val.EndsWith(","))
val = val + " " + doc.DocumentElement.FirstChild.ChildNodes[h].InnerText;
else
val = val + ", " + doc.DocumentElement.FirstChild.ChildNodes[h].InnerText;
}
}
val = val.Trim();
}
inFeature.set_Value(intFldIdxs[0], val);
}
}
catch
{
}
finally
{
req = null;
res = null;
xr = null;
doc = null;
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain97"));
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GET_ADDRESS_USING_ARCGIS_SERVICE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "GET_ADDRESS_USING_ARCGIS_SERVICE");
}
break;
case "TIMESTAMP":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TIMESTAMP");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length > 0)
{
try
{
if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
{
if (args[0].ToString().ToUpper() == "DATE")
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.Date);
}
else if (args[0].ToString().Trim() != "")
{
try
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString(args[0]));
}
catch
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString());
}
}
else
{
inObject.set_Value(intFldIdxs[0], DateTime.Now);
}
}
else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
{
if (args[0].ToString().ToUpper() == "DATE")
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.Date);
}
else if (args[0].ToString().ToUpper() == "TIME")
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString("hh:mm:ss tt"));
}
else if (args[0].ToString().ToUpper() == "TIME24")
{
// ReadOnlyCollection<System.TimeZoneInfo> timeZones = System.TimeZoneInfo.GetSystemTimeZones();
// string s = System.TimeZoneInfo.ConvertTime(DateTime.Now, timeZones[0]).ToString("HH:mm:ss");
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString("HH:mm:ss"));
}
else if (args[0].ToString().ToUpper() == "YEAR")
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.Year.ToString());
}
else if (args[0].ToString().ToUpper() == "MONTH")
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.Month.ToString());
}
else if (args[0].ToString().ToUpper() == "DAY")
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.DayOfWeek.ToString());
}
else if (args[0].ToString().Trim() != "")
{
try
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString(args[0]));
}
catch
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString());
}
}
else
{
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString());
}
}
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ag"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain98"));
if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
inObject.set_Value(intFldIdxs[0], DateTime.Now);
else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString());
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain98"));
if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
inObject.set_Value(intFldIdxs[0], DateTime.Now);
else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString());
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TIMESTAMP: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TIMESTAMP");
}
break;
case "LAST_VALUE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "LAST_VALUE");
bool CheckForValue = false;
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length > 0)
{
if (args[0].ToString().ToUpper() == "TRUE")
{
CheckForValue = true;
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain98"));
}
if (CheckForValue && (inObject.get_Value(intFldIdxs[0]) != null && inObject.get_Value(intFldIdxs[0]) != DBNull.Value))
{
}
else
{
if (mode == "ON_CREATE")
{
lastValue = AAState.lastValueProperties.GetProperty(strFldNames[0]) as LastValueEntry;
if (lastValue == null)
{
if (inObject.get_Value(intFldIdxs[0]) != null)
{
if (inObject.get_Value(intFldIdxs[0]) != DBNull.Value)
{
AAState.lastValueProperties.SetProperty(strFldNames[0], inObject.get_Value(intFldIdxs[0]));
}
}
}
else if (lastValue.Value != null)
{
if (lastValue.Value != DBNull.Value)
{
inObject.set_Value(intFldIdxs[0], lastValue.Value);
AAState.WriteLine(" " + strFldNames[0] + ": " + lastValue.Value);
}
}
else
{
if (inObject.get_Value(intFldIdxs[0]) != null)
{
if (inObject.get_Value(intFldIdxs[0]) != DBNull.Value)
{
AAState.lastValueProperties.SetProperty(strFldNames[0], inObject.get_Value(intFldIdxs[0]));
}
}
}
}
else if (mode == "ON_CHANGE")
{
IRowChanges pRowCh = inObject as IRowChanges;
changed = pRowCh.get_ValueChanged(intFldIdxs[0]);
if (!changed)
{
lastValue = AAState.lastValueProperties.GetProperty(strFldNames[0]) as LastValueEntry;
if (lastValue != null)
{
if (lastValue.Value != null)
{
inObject.set_Value(intFldIdxs[0], lastValue.Value);
AAState.WriteLine(" " + strFldNames[0] + ": " + lastValue.Value);
}
}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "LAST_VALUE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "LAST_VALUE");
}
break;
case "X_COORDINATE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "X_COORDINATE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.Shape as IPoint;
inFeature.set_Value(intFldIdxs[0], _copyPoint.X);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
if (valData.Trim() == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].X);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.FromPoint.X);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.ToPoint.X);
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].X);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
if (valData.Trim() == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolygon)[0].X);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], _copyPolygon.FromPoint.X);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], _copyPolygon.ToPoint.X);
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolygon)[0].X);
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ah"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "X_COORDINATE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "X_COORDINATE");
}
break;
case "Y_COORDINATE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "Y_COORDINATE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.Shape as IPoint;
inFeature.set_Value(intFldIdxs[0], _copyPoint.Y);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
if (valData == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].Y);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.FromPoint.Y);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.ToPoint.Y);
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].Y);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
if (valData.Trim() == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolygon)[0].Y);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], _copyPolygon.FromPoint.Y);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], _copyPolygon.ToPoint.Y);
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolygon)[0].Y);
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ah"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "Y_COORDINATE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "Y_COORDINATE");
}
break;
case "LATITUDE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "LATITUDE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.ShapeCopy as IPoint;
_copyPoint.Project(AAState._sr1);
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPoint.Y.ToString()));
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.ShapeCopy as IPolyline;
_copyPolyline.Project(AAState._sr1);
if (valData == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), Globals.GetGeomCenter(_copyPolyline)[0].Y.ToString()));
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPolyline.FromPoint.Y.ToString()));
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPolyline.ToPoint.Y.ToString()));
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), Globals.GetGeomCenter(_copyPolyline)[0].Y.ToString()));
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
_copyPolygon.Project(AAState._sr1);
if (valData.Trim() == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), Globals.GetGeomCenter(_copyPolygon)[0].Y.ToString()));
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPolygon.FromPoint.Y.ToString()));
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPolygon.ToPoint.Y.ToString()));
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), Globals.GetGeomCenter(_copyPolygon)[0].Y.ToString()));
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ah"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "LATITUDE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "LATITUDE");
}
break;
case "LONGITUDE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "LONGITUDE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.ShapeCopy as IPoint;
_copyPoint.Project(AAState._sr1);
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPoint.X.ToString()));
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
_copyPolyline.Project(AAState._sr1);
if (valData == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), Globals.GetGeomCenter(_copyPolyline)[0].X.ToString()));
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPolyline.FromPoint.X.ToString()));
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPolyline.ToPoint.X.ToString()));
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), Globals.GetGeomCenter(_copyPolyline)[0].X.ToString()));
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
_copyPolygon.Project(AAState._sr1);
if (valData.Trim() == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), Globals.GetGeomCenter(_copyPolygon)[0].X.ToString()));
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPolygon.FromPoint.X.ToString()));
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), _copyPolygon.ToPoint.X.ToString()));
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.FormatValueToFieldLength(inFeature.Fields.get_Field(intFldIdxs[0]), Globals.GetGeomCenter(_copyPolygon)[0].X.ToString()));
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ah"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "LONGITUDE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "LONGITUDE");
}
break;
case "FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "Field");
// verify that field to copy exists
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
fieldCopy = inObject.Fields.FindField(args[0] as string);
if (fieldCopy > -1)
{
bool useDisplayValue = true;
if (args.Length == 2)
{
if (args[1].ToUpper() == "CODE")
useDisplayValue = false;
}
try
{
if (useDisplayValue)
{
inObject.set_Value(intFldIdxs[0], Globals.GetDomainDisplay(inObject.get_Value(fieldCopy), inObject as IFeature, inObject.Fields.get_Field(fieldCopy)));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
}
else
{
inObject.set_Value(intFldIdxs[0], inObject.get_Value(fieldCopy));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + ex.Message);
}
}
else
{
AAState.WriteLine(" " + valData + " is not found");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "Field: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "Field");
}
break;
//CURRENT_USER
//Value Data options:
//U - windows username only
//W or (blank) - full username including domain i.e. domain\username
//D - database user if available and not dbo
case "CURRENT_USER":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "CURRENT_USER");
lastEditorName = AAState._currentUserInfo.GetCurrentUser(valData, fieldObj.Length);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain99") + lastEditorName);
if (!String.IsNullOrEmpty(lastEditorName))
{
inObject.set_Value(intFldIdxs[0], lastEditorName);
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "CURRENT_USER: "******"AttributeAssistantEditorMess_14as") + "CURRENT_USER");
}
break;
case "JUNCTION_ROTATION":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "JUNCTION_ROTATION");
if ((inFeature != null))
{
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolGeographic;
args = null;
AAState.rCalc.UseDiameter = false;
AAState.rCalc.DiameterFieldName = "";
AAState.rCalc.SpinAngle = 0;
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length == 0)
{
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolGeographic;
}
else if (args.Length == 1)
{
if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolArithmetic;
}
else if (args.Length == 2)
{
if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolArithmetic;
if (Globals.IsNumeric(args[1].ToString()))
AAState.rCalc.SpinAngle = Convert.ToDouble(args[1]);
}
else if (args.Length == 3)
{
if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolArithmetic;
if (Globals.IsNumeric(args[1].ToString()))
AAState.rCalc.SpinAngle = Convert.ToDouble(args[1]);
AAState.rCalc.UseDiameter = true;
AAState.rCalc.DiameterFieldName = args[2].ToString();
}
else
{
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolGeographic;
}
}
AAState.WriteLine(" " + AAState.rCalc.RotationType.ToString() + " is being used");
rotationAngle = AAState.rCalc.GetRotationUsingConnectedEdges(inFeature);
if (rotationAngle == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain100"));
continue;
}
//Accept optional second argument to provide extra rotation
if (rotationAngle != -1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain101") + rotationAngle.ToString());
inObject.set_Value(intFldIdxs[0], rotationAngle);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain102"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "JUNCTION_ROTATION \r\n" + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "JUNCTION_ROTATION");
}
break;
//For Release: 1.2
//New Dynamic Value Method: Length - stores calculated length of line feature
case "LENGTH":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "LENGTH");
if (inFeature != null)
{
curve = (ICurve)inFeature.Shape;
if (curve != null)
{
inObject.set_Value(intFldIdxs[0], curve.Length);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "LENGTH: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "LENGTH");
}
break;
//Release: 1.2
//New Dynamic Value Method: SET_MEASURES - stores calculated M values (from 0 to length of line) for line feature
//Value Data options:
//P = Percent - Ms will be zero to 100
//default - Ms will be zero to length of line
case "SET_MEASURES":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "SET_MEASURES");
if (inFeature != null)
{
curve = inFeature.Shape as ICurve;
mseg = inFeature.Shape as IMSegmentation;
if (curve != null && mseg != null)
if (valData != null && valData != "" && valData.Substring(0, 1).ToUpper() == "P")
mseg.SetAndInterpolateMsBetween(0, 100);
else
mseg.SetAndInterpolateMsBetween(0, curve.Length);
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "SET_MEASURES: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "SET_MEASURES");
}
break;
//case "EDGE_INTERSECT_SECOND":
// try
// {
// if (inFeature != null)
// {
// netFeat = inFeature as INetworkFeature;
// if (netFeat != null)
// {
// if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
// {
// iJuncFeat = (IJunctionFeature)netFeat;
// // IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
// ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
// if (iSJunc == null)
// break;
// if (iSJunc.EdgeFeatureCount <= 1)
// break;
// iEdgeFeat = iSJunc.get_EdgeFeature(1);
// // verify that field (in junction) to copy exists
// IRow pRow = iEdgeFeat as IRow;
// juncField = pRow.Fields.FindField(valData as string);
// if (juncField > -1)
// {
// inObject.set_Value(intFldIdxs[0], pRow.get_Value(juncField));
// }
// }
// }
// }
// }
// catch
// {
// }
// break;
//case "EDGE_INTERSECT_FIRST":
// try
// {
// if (inFeature != null)
// {
// netFeat = inFeature as INetworkFeature;
// if (netFeat != null)
// {
// if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
// {
// iJuncFeat = (IJunctionFeature)netFeat;
// // IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
// ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
// if (iSJunc == null)
// break;
// if (iSJunc.EdgeFeatureCount <= 0)
// break;
// iEdgeFeat = iSJunc.get_EdgeFeature(0);
// IRow pRow = iEdgeFeat as IRow;
// juncField = pRow.Fields.FindField(valData as string);
// if (juncField > -1)
// {
// inObject.set_Value(intFldIdxs[0], pRow.get_Value(juncField));
// }
// }
// }
// }
// }
// catch
// {
// }
// break;
//Release: 2.0
//New Dynamic Value Method: TO_EDGE_FIELD transfers a field value from a connected egde feature to a junction feature
//Takes value from the frist edge whose "TO" point connects with this junction
case "TO_EDGE_FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TO_EDGE_FIELD");
if (inFeature != null)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iEdgeFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
continue;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iEdgeFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
//IFeature pTest = ((IFeature)iEdgeFeat);
if (((IFeature)iEdgeFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
continue;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
iJuncFeat = (IJunctionFeature)iEdgeFeat.FromJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(pRow.Fields, netField);
if (juncField > -1)
{
inObject.set_Value(intFldIdxs[0], pRow.get_Value(juncField));
}
else
{
AAState.WriteLine(" " + netField + " field not found in edge");
}
pRow = null;
break;
}
}
catch
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14an"));
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
iSJunc = null;
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TO_EDGE_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TO_EDGE_FIELD");
}
break;
//Release: 2.0
//New Dynamic Value Method: FROM_EDGE_FIELD transfers a field value from a connected egde feature to a junction feature
//Takes value from the frist edge whose "FROM" point connects with this junction
case "FROM_EDGE_FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "FROM_EDGE_FIELD");
if (inFeature != null)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iEdgeFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
continue;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iEdgeFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
//IFeature pTest = ((IFeature)iEdgeFeat);
if (((IFeature)iEdgeFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
continue;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(pRow.Fields, netField);
if (juncField > -1)
{
inObject.set_Value(intFldIdxs[0], pRow.get_Value(juncField));
}
else
{
AAState.WriteLine(" " + iSJunc + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am") );
}
pRow = null;
break;
}
}
catch
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14an"));
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
iSJunc = null;
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "FROM_EDGE_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "FROM_EDGE_FIELD");
}
break;
case "TO_EDGE_STATS":
try
{
if (valData == null) break;
args = valData.Split('|');
string statType = "MAX";
switch (args.GetLength(0))
{
case 1:
sourceFieldName = args[0].ToString();
break;
case 2:
sourceFieldName = args[0].ToString();
statType = args[1].ToString();
break;
default: break;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TO_EDGE_STATS");
int AverageCount = 0;
double result = -999999.1;
string textRes = "";
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain103"));
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain104"));
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain106"));
iJuncFeat = iEdgeFeat.FromJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain107"));
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain108"));
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14d") + test);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain109"));
}
}
catch
{
}
}//end loop
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aj") + ex.Message);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TO_EDGE_STATS");
}
break;
case "FROM_EDGE_STATS":
try
{
if (valData == null) break;
args = valData.Split('|');
string statType = "MAX";
switch (args.GetLength(0))
{
case 1:
sourceFieldName = args[0].ToString();
break;
case 2:
sourceFieldName = args[0].ToString();
statType = args[1].ToString();
break;
default: break;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "FROM_EDGE_STATS");
int AverageCount = 0;
double result = -999999.1;
string textRes = "";
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain103"));
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain104"));
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain106"));
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain110"));
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain111"));
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14d") + test);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain112"));
}
}
catch
{
}
}//end loop
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aj") + ex.Message);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TO_EDGE_STATS");
}
break;
case "EDGE_STATS":
try
{
if (valData == null) break;
args = valData.Split('|');
string statType = "MAX";
switch (args.GetLength(0))
{
case 1:
sourceFieldName = args[0].ToString();
break;
case 2:
sourceFieldName = args[0].ToString();
statType = args[1].ToString();
break;
default: break;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "EDGE_STATS");
int AverageCount = 0;
double result = -999999.1;
string textRes = "";
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain103"));
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain104"));
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain113"));
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14d") + test);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
catch
{
}
}//end loop
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aj") + ex.Message);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TO_EDGE_STATS");
}
break;
case "TO_EDGE_MULTI_FIELD_INTERSECT":
try
{
if (valData == null) break;
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int popFldIdx = 0;
if (args.GetLength(0) >= 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain114"));
sourceFieldName = args[0].ToString();
string[] fieldsToPop = args[1].ToString().Split(',');
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TO_EDGE_MULTI_FIELD_INTERSECT");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain103"));
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain104"));
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain106"));
iJuncFeat = iEdgeFeat.FromJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain107"));
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain108"));
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (fieldsToPop.Length == popFldIdx)
break;
int tempFieldNum = inObject.Fields.FindField(fieldsToPop[popFldIdx]);
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, test);
popFldIdx++;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain109"));
}
}
catch
{
}
}//end loop
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TO_EDGE_STATS");
}
break;
case "FROM_EDGE_MULTI_FIELD_INTERSECT":
try
{
if (valData == null) break;
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int popFldIdx = 0;
if (args.GetLength(0) >= 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain114"));
sourceFieldName = args[0].ToString();
string[] fieldsToPop = args[1].ToString().Split(',');
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "FROM_EDGE_MULTI_FIELD_INTERSECT");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain103"));
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain104"));
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain106"));
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain110"));
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain111"));
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (fieldsToPop.Length == popFldIdx)
break;
int tempFieldNum = inObject.Fields.FindField(fieldsToPop[popFldIdx]);
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, test);
popFldIdx++;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain112"));
}
}
catch
{
}
}//end loop
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TO_EDGE_STATS");
}
break;
case "FROM_JUNCTION_FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "FROM_JUNCTION_FIELD");
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iEdgeFeat = (IEdgeFeature)netFeat;
iJuncFeat = iEdgeFeat.FromJunctionFeature;
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iJuncFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
break;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
if (((IFeature)iJuncFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
break;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netField);
if (juncField > -1)
{
inObject.set_Value(intFldIdxs[0], ((IFeature)iJuncFeat).get_Value(juncField));
}
else
AAState.WriteLine(" " + netField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am") );
}
else
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bc"));
}
else
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain115"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "FROM_JUNCTION_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "FROM_JUNCTION_FIELD");
}
break;
//Release: 1.2
//New Dynamic Value Method: TO_JUNCTION_FIELD transfers a field value from a junction connected at terminal end of a line feature
case "TO_JUNCTION_FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TO_JUNCTION_FIELD");
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iEdgeFeat = (IEdgeFeature)netFeat;
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iJuncFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
break;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
if (((IFeature)iJuncFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
break;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netField);
//juncField = ((IFeature)iJuncFeat).Fields.FindField(valData as string);
if (juncField > -1)
{
inObject.set_Value(intFldIdxs[0], ((IFeature)iJuncFeat).get_Value(juncField));
}
else
{
AAState.WriteLine(" " + netField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am") );
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bc"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bd"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TO_JUNCTION_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TO_JUNCTION_FIELD");
}
break;
case "UPDATE_TO_JUNCTION_FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "UPDATE_TO_JUNCTION_FIELD");
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == true)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iEdgeFeat = (IEdgeFeature)netFeat;
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iJuncFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
break;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
if (((IFeature)iJuncFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
break;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netField);
//juncField = ((IFeature)iJuncFeat).Fields.FindField(valData as string);
if (juncField > -1)
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
((IFeature)iJuncFeat).set_Value(juncField, inObject.get_Value(intFldIdxs[0]));
ChangeFeatureList.Add(((IFeature)iJuncFeat));
}
else
{
AAState.WriteLine(" " + netField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am") );
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bc"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bd"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14be"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "UPDATE_TO_JUNCTION_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "UPDATE_TO_JUNCTION_FIELD");
}
break;
case "UPDATE_FROM_JUNCTION_FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "UPDATE_FROM_JUNCTION_FIELD");
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == true)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1:
netField = args[0].ToString().Trim();
break;
case 2:
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3:
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4:
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iEdgeFeat = (IEdgeFeature)netFeat;
iJuncFeat = iEdgeFeat.FromJunctionFeature;
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iJuncFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
break;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
if (((IFeature)iJuncFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
break;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netField);
//juncField = ((IFeature)iJuncFeat).Fields.FindField(valData as string);
if (juncField > -1)
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
((IFeature)iJuncFeat).set_Value(juncField, inObject.get_Value(intFldIdxs[0]));
ChangeFeatureList.Add(((IFeature)iJuncFeat));
}
else
{
AAState.WriteLine(" " + netField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am") );
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bc"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bd"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14be"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "UPDATE_FROM_JUNCTION_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "UPDATE_FROM_JUNCTION_FIELD");
}
break;
case "UPDATE_FROM_EDGE_FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "UPDATE_FROM_EDGE_FIELD");
if (inFeature != null)
{
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == true)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iEdgeFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
continue;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iEdgeFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
//IFeature pTest = ((IFeature)iEdgeFeat);
if (((IFeature)iEdgeFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
continue;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
IFeature pRow = iEdgeFeat as IFeature;
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(pRow.Fields, netField);
if (juncField > -1)
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
pRow.set_Value(juncField, inObject.get_Value(intFldIdxs[0]));
ChangeFeatureList.Add(((IFeature)pRow));
}
else
{
AAState.WriteLine(" " + iSJunc + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14am") );
}
pRow = null;
break;
}
}
catch
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14an"));
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
iSJunc = null;
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14be"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "UPDATE_FROM_EDGE_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "UPDATE_FROM_EDGE_FIELD");
}
break;
case "UPDATE_TO_EDGE_FIELD":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "UPDATE_TO_EDGE_FIELD");
if (inFeature != null)
{
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == true)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iEdgeFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
continue;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iEdgeFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
//IFeature pTest = ((IFeature)iEdgeFeat);
if (((IFeature)iEdgeFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
continue;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
iJuncFeat = (IJunctionFeature)iEdgeFeat.FromJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
IFeature pRow = iEdgeFeat as IFeature;
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(pRow.Fields, netField);
if (juncField > -1)
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
pRow.set_Value(juncField, inObject.get_Value(intFldIdxs[0]));
ChangeFeatureList.Add(((IFeature)pRow));
}
else
{
AAState.WriteLine(" " + netField + " field not found in edge");
}
pRow = null;
break;
}
}
catch
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14an"));
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
iSJunc = null;
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14be"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "UPDATE_TO_EDGE_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "UPDATE_TO_EDGE_FIELD");
}
break;
//***************8
case "TRIGGER_UPDATE_INTERSECTING_FEATURE"://Intersected Feature|FieldIntersectingFeatureToChange|FromFieldinModifiedFeature
{
try
{
IFeatureCursor fLocalCursor = null;
IFeature sourceFeatureLocal = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TRIGGER_UPDATE_INTERSECTING_FEATURE");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 3)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
if (inFeature == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ak"));
break;
}
bool cont = true;
if (intFldIdxs.Count > 1)
{
IRowChanges inChanges = inObject as IRowChanges;
if (inChanges.get_ValueChanged(intFldIdxs[0]))
{
cont = true;
}
else
{
cont = false;
}
inChanges = null;
}
if (cont)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bs"));
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString().Trim();
string targetFieldName = args[2].ToString().Trim();
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bt"));
if (sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString().Trim();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0].Trim();
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
if (Globals.IsEditable(ref sourceLayer, ref AAState._editor))
{
if (inObject.Class.ObjectClassID != sourceLayer.FeatureClass.ObjectClassID)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, false, out cCurs);
fLocalCursor = cCurs as IFeatureCursor;
}
else
{
fLocalCursor = sourceLayer.Search(sFilter, false);
}
}
else
{
fLocalCursor = sourceLayer.FeatureClass.Search(sFilter, false);
}
while ((sourceFeatureLocal = fLocalCursor.NextFeature()) != null)
{
try
{
if (sourceFeatureLocal.Class.ObjectClassID != inFeature.Class.ObjectClassID)
{
if (sourceFieldName == "CREATE")
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
NewFeatureList.Add(((IFeature)sourceFeatureLocal));
}
else if (sourceFieldName == "CHANGEGEO")
{
if (ChangeFeatureGeoList == null)
{
ChangeFeatureGeoList = new List<IObject>();
}
ChangeFeatureGeoList.Add(((IFeature)sourceFeatureLocal));
}
else
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(((IFeature)sourceFeatureLocal));
}
}
else if (sourceFeatureLocal.Class == inFeature.Class && sourceFeatureLocal.OID != inFeature.OID)
{
if (sourceFieldName == "CREATE")
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
NewFeatureList.Add(((IFeature)sourceFeatureLocal));
}
else if (sourceFieldName == "CHANGEGEO")
{
if (ChangeFeatureGeoList == null)
{
ChangeFeatureGeoList = new List<IObject>();
}
ChangeFeatureGeoList.Add(((IFeature)sourceFeatureLocal));
}
else
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(((IFeature)sourceFeatureLocal));
}
}
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14al"));
}
finally
{
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14am") + sourceFieldName);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14am") + sourceFieldName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14b") + sourceLayerName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14c") + sourceLayerName);
}
}
}
if (found)
{
break;
}
}
fLocalCursor = null;
sourceFeatureLocal = null;
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TRIGGER_UPDATE_INTERSECTING_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TRIGGER_UPDATE_INTERSECTING_FEATURE");
}
break;
}
case "TRIGGER_UPDATE_TO_JUNCTION":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TRIGGER_UPDATE_TO_JUNCTION");
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == true)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iEdgeFeat = (IEdgeFeature)netFeat;
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iJuncFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
break;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
if (((IFeature)iJuncFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
break;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
// verify that field (in junction) to copy exists
if (netField == "CREATE")
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
NewFeatureList.Add(((IFeature)iJuncFeat));
}
else if (netField == "CHANGEGEO")
{
if (ChangeFeatureGeoList == null)
{
ChangeFeatureGeoList = new List<IObject>();
}
ChangeFeatureGeoList.Add(((IFeature)iJuncFeat));
}
else
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(((IFeature)iJuncFeat));
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bc"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bd"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14be"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TRIGGER_UPDATE_TO_JUNCTION: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TRIGGER_UPDATE_TO_JUNCTION");
}
break;
case "TRIGGER_UPDATE_FROM_JUNCTION":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TRIGGER_UPDATE_FROM_JUNCTION");
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == true)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1:
netField = args[0].ToString().Trim();
break;
case 2:
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3:
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4:
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iEdgeFeat = (IEdgeFeature)netFeat;
iJuncFeat = iEdgeFeat.FromJunctionFeature;
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iJuncFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
break;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
if (((IFeature)iJuncFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
break;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
if (netField == "CREATE")
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
NewFeatureList.Add(((IFeature)iJuncFeat));
}
else if (netField == "CHANGEGEO")
{
if (ChangeFeatureGeoList == null)
{
ChangeFeatureGeoList = new List<IObject>();
}
ChangeFeatureGeoList.Add(((IFeature)iJuncFeat));
}
else
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(((IFeature)iJuncFeat));
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bc"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bd"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14be"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TRIGGER_UPDATE_FROM_JUNCTION: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TRIGGER_UPDATE_FROM_JUNCTION");
}
break;
case "TRIGGER_UPDATE_FROM_EDGE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TRIGGER_UPDATE_FROM_EDGE");
if (inFeature != null)
{
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == true)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iEdgeFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
continue;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iEdgeFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
//IFeature pTest = ((IFeature)iEdgeFeat);
if (((IFeature)iEdgeFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
continue;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
if (netField == "CREATE")
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
NewFeatureList.Add(((IFeature)iEdgeFeat));
}
else if (netField == "CHANGEGEO")
{
if (ChangeFeatureGeoList == null)
{
ChangeFeatureGeoList = new List<IObject>();
}
ChangeFeatureGeoList.Add(((IFeature)iEdgeFeat));
}
else
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(((IFeature)iEdgeFeat));
}
break;
}
}
catch
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14an"));
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
iSJunc = null;
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14be"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TRIGGER_UPDATE_FROM_EDGE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TRIGGER_UPDATE_FROM_EDGE");
}
break;
case "TRIGGER_UPDATE_TO_EDGE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "TRIGGER_UPDATE_TO_EDGE");
if (inFeature != null)
{
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == true)
{
if (valData == null)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ba"));
break;
}
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iEdgeFeat).Class));
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bf") + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bg"));
continue;
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bh"));
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iEdgeFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
//IFeature pTest = ((IFeature)iEdgeFeat);
if (((IFeature)iEdgeFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bl"));
continue;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bm"));
}
}
iJuncFeat = (IJunctionFeature)iEdgeFeat.FromJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
if (netField == "CREATE")
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
NewFeatureList.Add(((IFeature)iEdgeFeat));
}
else if (netField == "CHANGEGEO")
{
if (ChangeFeatureGeoList == null)
{
ChangeFeatureGeoList = new List<IObject>();
}
ChangeFeatureGeoList.Add(((IFeature)iEdgeFeat));
}
else
{
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(((IFeature)iEdgeFeat));
}
break;
break;
}
}
catch
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14an"));
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
iSJunc = null;
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14be"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "TRIGGER_UPDATE_TO_EDGE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "TRIGGER_UPDATE_TO_EDGE");
}
break;
//***********8
//Release: 1.2
//New Dynamic Value Method: GENERATE_ID - uses value in specificed table and increments it as specified
case "GENERATE_ID":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "GENERATE_ID");
if (AAState._gentab != null)
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
formatString = "";
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
sequenceColumnName = args[0].ToString(); break;
case 2: // sequenceColumnName|sequenceFixedWidth
sequenceColumnName = args[0].ToString();
sequenceFixedWidth = args[1].ToString();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
sequenceColumnName = args[0].ToString();
sequenceFixedWidth = args[1].ToString();
formatString = args[2].ToString();
break;
default: break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
if (sequencePadding > 25)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain116"));
AAState.WriteLine(" WARNING: " + sequencePadding + " 0's is what you have");
}
else if (sequencePadding > 50)
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain117"));
}
qFilter = new QueryFilterClass();
qFilter.WhereClause = "SEQNAME = '" + sequenceColumnName + "'";
cCurs = AAState._gentab.Update(qFilter, false);
sequenceColumnNum = AAState._gentab.Fields.FindField("SEQCOUNTER");
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = cCurs.NextRow();
if (row == null)
{
break;
}
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
// _editEvents.OnChangeFeature -= OnChangeFeature;
// _editEvents.OnCreateFeature -= OnCreateFeature;
int sequenceInt = 1;
if (AAState._gentab.Fields.FindField("SEQINTERV") > 0)
{
if (row.get_Value(AAState._gentab.Fields.FindField("SEQINTERV")) != null)
{
if (row.get_Value(AAState._gentab.Fields.FindField("SEQINTERV")) != DBNull.Value)
sequenceInt = Convert.ToInt32(row.get_Value(AAState._gentab.Fields.FindField("SEQINTERV")));
}
}
sequenceValue = sequenceValue + sequenceInt;
row.set_Value(sequenceColumnNum, sequenceValue);
AAState.WriteLine(" " + row.Fields.get_Field(sequenceColumnNum).AliasName + " changed to " + sequenceValue);
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
row.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
// _editEvents.OnChangeFeature += OnChangeFeature;
// _editEvents.OnCreateFeature += OnCreateFeature;
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GENERATE_ID: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ao"));
}
else
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || formatString.ToLower().IndexOf("[seq]") == -1)
{
string setVal = (sequenceValue.ToString("D" + sequencePadding) + sequencePostfix).ToString();
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < setVal.Length && inObject.Fields.get_Field(intFldIdxs[0]).Length != 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sequenceValue + " is to long for field " + row.Fields.get_Field(sequenceColumnNum).AliasName);
}
else
{
inObject.set_Value(intFldIdxs[0], (sequenceValue.ToString("D" + sequencePadding) + sequencePostfix).Trim());
AAState.WriteLine(" " + inObject.Fields.get_Field(intFldIdxs[0]).AliasName + " set to " + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
}
}
else
{
int locIdx = formatString.ToUpper().IndexOf("[SEQ]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 5);
formatString = formatString.Insert(locIdx, sequenceValue.ToString("D" + sequencePadding));
}
//formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < formatString.Length && inObject.Fields.get_Field(intFldIdxs[0]).Length != 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + formatString + " is to long for field " + row.Fields.get_Field(sequenceColumnNum).AliasName);
}
else
{
inObject.set_Value(intFldIdxs[0], formatString.Trim());
AAState.WriteLine(" " + inObject.Fields.get_Field(intFldIdxs[0]).AliasName + " set to " + formatString);
}
}
else
{
inObject.set_Value(intFldIdxs[0], sequenceValue);
AAState.WriteLine(" " + sequenceColumnNum + " changed to " + sequenceValue);
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GENERATE_ID: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ap"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GENERATE_ID: " + ex.Message);
}
finally
{
if (cCurs != null)
{
Marshal.ReleaseComObject(cCurs);
GC.Collect(300);
GC.WaitForFullGCComplete();
cCurs = null;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "GENERATE_ID");
}
break;
case "GENERATE_ID_BY_INTERSECT":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "GENERATE_ID_BY_INTERSECT");
if (AAState._gentab != null && inFeature != null && !(inFeature.Shape.IsEmpty))
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
//genIdAreaFieldName = "";
intersectLayerName = "";
intersectLayerFieldName = "";
formatString = "";
intersectFieldPos = -1;
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
if (args.GetLength(0) < 3)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GENERATE_ID: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ap"));
break;
}
switch (args.GetLength(0))
{
case 3: //columnName
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
// genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
break;
case 4: // columnName|sequenceFixedWidth
//sequenceFixedWidth formats the sequence with leading zeros to create specified width
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
sequenceFixedWidth = Convert.ToString(0);
formatString = args[3].ToString();
break;
case 5: // columnName|sequenceFixedWidth|formatString
//formatString must contain [seq] and [id] and may contain [area] plus any desired text
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
sequenceFixedWidth = args[3].ToString();
formatString = args[4].ToString();
break;
default: break;
}
//Find Area Layer
// FindLayerByName(areaLayerName, out areaLayer);
boolLayerOrFC = true;
if (intersectLayerName.Contains("("))
{
string[] tempSplt = intersectLayerName.Split('(');
intersectLayerName = tempSplt[0];
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC);
}
if (intersectLayer == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aq") +"(" + intersectLayerName + ") not found");
break;
}
//Find Area Field
intersectFieldPos = intersectLayer.FeatureClass.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14as") +"(" + intersectLayerFieldName + ") not found");
break;
}
//Perform spatial search
IGeometry pSearchGeo = Globals.GetGeomCenter((IGeometry)inFeature.ShapeCopy)[0];
pSearchGeo.SpatialReference = (inFeature.Class as IGeoDataset).SpatialReference;
pSearchGeo.Project((intersectLayer as IGeoDataset).SpatialReference);
sFilter = Globals.createSpatialFilter(intersectLayer, inFeature, false);
pFS = (IFeatureSelection)intersectLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = intersectLayer.Search(sFilter, true);
}
}
else
{
fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
intersectValue = "-9999.1";
if (sourceFeature == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14at"));
break;
}
else
{
while (sourceFeature != null)
{
if (sourceFeature.Class != inFeature.Class)
{
intersectValue = sourceFeature.get_Value(intersectFieldPos).ToString();
break;
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
intersectValue = sourceFeature.get_Value(intersectFieldPos).ToString();
break;
}
sourceFeature = fCursor.NextFeature();
}
}
if (intersectValue == "-9999.1")
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14at"));
break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
if (sequencePadding > 25)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain116"));
AAState.WriteLine(" WARNING: " + sequencePadding + " 0's is what you have");
}
sequenceColumnName = sequenceColumnName + intersectValue;
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bn") + sequenceColumnName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bo"));
qFilter = new QueryFilterClass();
qFilter.WhereClause = "SEQNAME = '" + sequenceColumnName + "'";
cCurs = AAState._gentab.Update(qFilter, false);
sequenceColumnNum = AAState._gentab.Fields.FindField("SEQCOUNTER");
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = cCurs.NextRow();
if (row == null)
{
break;
}
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
int sequenceInt = 1;
if (AAState._gentab.Fields.FindField("SEQINTERV") > 0)
{
if (row.get_Value(AAState._gentab.Fields.FindField("SEQINTERV")) != null)
{
if (row.get_Value(AAState._gentab.Fields.FindField("SEQINTERV")) != DBNull.Value)
sequenceInt = Convert.ToInt32(row.get_Value(AAState._gentab.Fields.FindField("SEQINTERV")));
}
}
sequenceValue = sequenceValue + sequenceInt;
row.set_Value(sequenceColumnNum, sequenceValue);
row.Store();
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14au"));
}
else
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || (formatString.ToUpper().IndexOf("[SEQ]") == -1 && formatString.ToUpper().IndexOf("[ID]") == -1))
inObject.set_Value(intFldIdxs[0], intersectValue + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
else
{
int locIdx = formatString.ToUpper().IndexOf("[ID]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 4);
formatString = formatString.Insert(locIdx, intersectValue);
}
locIdx = formatString.ToUpper().IndexOf("[SEQ]");
if (locIdx >= 0)
{
string sequenceValuePad = sequenceValue.ToString("D" + sequencePadding);
formatString = formatString.Remove(locIdx, 5);
formatString = formatString.Insert(locIdx, sequenceValuePad.ToString());
}
//
inObject.set_Value(intFldIdxs[0], formatString);
}
else
inObject.set_Value(intFldIdxs[0], sequenceValue);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GENERATE_ID: " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ap"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "GENERATE_ID_BY_INTERSECT: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "GENERATE_ID_BY_INTERSECT");
}
break;
//Modified for Release 1.2 (No longer uses ICalculator)
//Requires valid VBScript expression
//Can include string, numeric, and date fields by name in square brackets []
//Example: DateDiff("yyyy",[INSTALLDATE],Now())
case "EXPRESSION":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "EXPRESSION");
if (inObject != null & valData != null)
{
int intTargetFld = -1;
if (intFldIdxs.Count == 0)
{
}
else
{
intTargetFld = intFldIdxs[0];
}
newValue = valData;
for (int i = 0; i <= inObject.Fields.FieldCount; i++)
{
string strTmpFldName;
int intTmpIdx;
if (i == inObject.Fields.FieldCount)
{
testField = inObject.Fields.get_Field(intFldIdxs[0]);
strTmpFldName = "#";
intTmpIdx = intFldIdxs[0];
}
else
{
testField = inObject.Fields.get_Field(i);
strTmpFldName = testField.Name;
intTmpIdx = i;
}
int indFld = newValue.ToUpper().IndexOf("[" + strTmpFldName.ToUpper() + "]");
while (indFld >= 0)
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bp") + testField.Name + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bq"));
int fldLen = strTmpFldName.Length;
string tmpStr1 = newValue.Substring(0, indFld + 1);
string tmpStr2 = newValue.Substring(indFld + fldLen + 1);
newValue = tmpStr1 + "_REPLACE_VAL_" + tmpStr2;
switch (testField.Type)
{
case esriFieldType.esriFieldTypeString:
if (inObject.get_Value(intTmpIdx) == null || inObject.get_Value(intTmpIdx).ToString() == "")
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("isNull"))
{
newValue = newValue.Replace("isNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("ISNULL"))
{
newValue = newValue.Replace("ISNULL([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(intTmpIdx) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx) == DBNull.Value)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
}
break;
case esriFieldType.esriFieldTypeDate:
if (inObject.get_Value(intTmpIdx) == null || inObject.get_Value(intTmpIdx).ToString() == "" || inObject.get_Value(intTmpIdx) == DBNull.Value)
{
if (newValue.Contains("IsNull([" + "_REPLACE_VAL_" + "])"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("isNull([" + "_REPLACE_VAL_" + "])"))
{
newValue = newValue.Replace("isNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("ISNULL([" + "_REPLACE_VAL_" + "])"))
{
newValue = newValue.Replace("ISNULL([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(intTmpIdx) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else if (inObject.get_Value(intTmpIdx) == DBNull.Value)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");//"\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else if (inObject.get_Value(intTmpIdx).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "CDATE(\"" + inObject.get_Value(intTmpIdx).ToString() + "\")");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "CDATE(\"" + inObject.get_Value(intTmpIdx).ToString() + "\")");
}
}
break;
case esriFieldType.esriFieldTypeDouble:
if (inObject.get_Value(intTmpIdx) == null || inObject.get_Value(intTmpIdx).ToString() == "")
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("isNull"))
{
newValue = newValue.Replace("isNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("ISNULL"))
{
newValue = newValue.Replace("ISNULL([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(intTmpIdx) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx) == DBNull.Value)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "" + inObject.get_Value(intTmpIdx).ToString() + "");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
double val;
Double.TryParse(inObject.get_Value(intTmpIdx).ToString(), out val);
// ' string test2 = test.ToString("N",nfi);
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", val.ToString("N", nfi));
}
}
break;
default:
if (inObject.get_Value(intTmpIdx) == null || inObject.get_Value(intTmpIdx).ToString() == "")
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("isNull"))
{
newValue = newValue.Replace("isNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("ISNULL"))
{
newValue = newValue.Replace("ISNULL([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(intTmpIdx) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx) == DBNull.Value)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "" + inObject.get_Value(intTmpIdx).ToString() + "");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", inObject.get_Value(intTmpIdx).ToString());
}
}
break;
}
indFld = newValue.ToUpper().IndexOf("[" + testField.Name.ToUpper() + "]");
}
}
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain118"));
if (intTargetFld > -1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14br") + newValue);
newValue = script.Eval(newValue).ToString();
if (newValue.ToUpper() == "<Null>".ToUpper())
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain119"));
inObject.set_Value(intTargetFld, DBNull.Value);
}
else if (inObject.get_Value(intTargetFld).ToString() != newValue)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain120") + newValue.Trim());
inObject.set_Value(intTargetFld, newValue.Trim());
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14av") + inObject.Class.AliasName + " with OID of " + inObject.OID);
AAState.WriteLine(" " + ex.Message);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "EXPRESSION: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "EXPRESSION");
}
break;
// GUID values are calculated into text fields or into native GUID field types
// When using text field you have an optional argument (valdata) to specify the format
// N-none 32 chars, D-dash 36, B-braces 38, P-Parenthesis 38
case "GUID":
try
{
if (inObject != null)
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeGUID)
inObject.set_Value(intFldIdxs[0], System.Guid.NewGuid().ToString("B"));
else if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString &&
inObject.Fields.get_Field(intFldIdxs[0]).Length >= 32)
{
valData = valData.Trim();
if (valData != "N" && valData != "D" && valData != "B" && valData != "P")
if (inObject.Fields.get_Field(intFldIdxs[0]).Length >= 38)
valData = "B"; //Default to braces
else if (inObject.Fields.get_Field(intFldIdxs[0]).Length < 36)
valData = "N";
else
valData = "D";
inObject.set_Value(intFldIdxs[0], System.Guid.NewGuid().ToString(valData));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "EXPRESSION: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "EXPRESSION");
}
break;
case "CREATE_LINKED_RECORD"://Feature Layer|Field To Copy|Field To Populate|Primary Key Field|Foreign Key Field
{
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "CREATE_LINKED_RECORD");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length < 5)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
if (inObject == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ak"));
break;
}
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bs"));
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString().Trim();
string targetFieldName = args[2].ToString().Trim();
string sourceIDFieldName = args[3].ToString().Trim();
string targetIDFieldName = args[4].ToString().Trim();
int countFld = 1;
if (args.Length == 6)
{
if (!Globals.IsNumeric(args[5].ToString().Trim()))
{
int fldx = Globals.GetFieldIndex(inObject.Fields, args[5].ToString().Trim());
if (fldx > 0)
{
string tempVal = inObject.get_Value(fldx).ToString();
if (Globals.IsNumeric(tempVal))
countFld = Convert.ToInt32(tempVal);
}
}
else
{
countFld = Convert.ToInt32(args[5].ToString().Trim());
}
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bt"));
if (sourceFieldName != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain121"));
int fldValToCopyIdx = Globals.GetFieldIndex(inObject.Fields, sourceFieldName);
int fldIDToCopyIdx = Globals.GetFieldIndex(inObject.Fields, sourceIDFieldName);
if (fldValToCopyIdx > -1 && fldIDToCopyIdx > -1)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString().Trim();
if (sourceLayerName != "")
{
// Get layer
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain122"));
bool FCorLayerSource = true;
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref FCorLayerSource);
if (sourceLayer != null)
{
AAState.WriteLine(" " + sourceLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
else
{
ITable pTable = Globals.FindTable(AAState._editor.Map, sourceLayerName);
if (pTable != null)
{
int fldValToPopIdx = Globals.GetFieldIndex(pTable.Fields, targetFieldName);
int fldIDToPopIdx = Globals.GetFieldIndex(pTable.Fields, targetIDFieldName);
if (fldValToPopIdx > -1 && fldIDToPopIdx > -1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain123"));
IRow pNewRow;
for (int j = 0; j < countFld; j++)
{
pNewRow = pTable.CreateRow();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain124"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain125"));
try
{
pNewRow.set_Value(fldIDToPopIdx, inObject.get_Value(fldIDToCopyIdx));
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aw") + inObject.get_Value(fldIDToCopyIdx) + " to field: " + targetIDFieldName);
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain126"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain127"));
try
{
pNewRow.set_Value(fldValToPopIdx, inObject.get_Value(fldValToCopyIdx));
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aw") + inObject.get_Value(fldValToCopyIdx) + " to field: " + targetFieldName);
}
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
IObject featobj = pNewRow as IObject;
if (featobj != null)
{
NewFeatureList.Add(featobj);
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain128"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14k"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ax") + sourceLayerName);
}
}
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ay"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "CREATE_LINKED_RECORD" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "CREATE_LINKED_RECORD");
}
break;
}
case "UPDATE_INTERSECTING_FEATURE"://Intersected Feature|FieldIntersectingFeatureToChange|FromFieldinModifiedFeature
{
try
{
IFeatureCursor fLocalCursor = null;
IFeature sourceFeatureLocal = null;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "UPDATE_INTERSECTING_FEATURE");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 3)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ad"));
break;
}
if (inFeature == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ak"));
break;
}
bool cont = true;
if (intFldIdxs.Count > 1)
{
IRowChanges inChanges = inObject as IRowChanges;
if (inChanges.get_ValueChanged(intFldIdxs[0]))
{
cont = true;
}
else
{
cont = false;
}
inChanges = null;
}
if (cont)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bs"));
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString().Trim();
string targetFieldName = args[2].ToString().Trim();
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bt"));
if (sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString().Trim();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0].Trim();
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
if (Globals.IsEditable(ref sourceLayer, ref AAState._editor))
{
if (inObject.Class.ObjectClassID != sourceLayer.FeatureClass.ObjectClassID)
{
sourceField = Globals.GetFieldIndex(sourceLayer.FeatureClass.Fields, sourceFieldName);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
int fldIdx = Globals.GetFieldIndex(inFeature.Fields, targetFieldName);
AAState.WriteLine(" " + targetFieldName + " at index " + fldIdx);
string test = targetFieldName;
if (fldIdx > -1)
{
test = inFeature.get_Value(fldIdx).ToString().Trim();
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bu") + test);
}
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bv") + test);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, false, out cCurs);
fLocalCursor = cCurs as IFeatureCursor;
}
else
{
fLocalCursor = sourceLayer.Search(sFilter, false);
}
}
else
{
fLocalCursor = sourceLayer.FeatureClass.Search(sFilter, false);
}
while ((sourceFeatureLocal = fLocalCursor.NextFeature()) != null)
{
try
{
if (sourceFeatureLocal.Class.ObjectClassID != inFeature.Class.ObjectClassID)
{
if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeString)
{
sourceFeatureLocal.set_Value(sourceField, test);
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
else
{
if (Globals.IsNumeric(test))
{
if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSmallInteger ||
sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeInteger)
{
sourceFeatureLocal.set_Value(sourceField, Convert.ToInt32(test));
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
//break;
}
else if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeDouble ||
sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSingle)
{
sourceFeatureLocal.set_Value(sourceField, Convert.ToDouble(test));
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
else
{
sourceFeatureLocal.set_Value(sourceField, test as object);
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
}
else
{
sourceFeatureLocal.set_Value(sourceField, test as object);
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
}
}
else if (sourceFeatureLocal.Class == inFeature.Class && sourceFeatureLocal.OID != inFeature.OID)
{
if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeString)
{
sourceFeatureLocal.set_Value(sourceField, test);
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
else
{
if (Globals.IsNumeric(test))
{
if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSmallInteger ||
sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeInteger)
{
sourceFeatureLocal.set_Value(sourceField, Convert.ToInt32(test));
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
else if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeDouble ||
sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSingle)
{
sourceFeatureLocal.set_Value(sourceField, Convert.ToDouble(test));
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
else
{
sourceFeatureLocal.set_Value(sourceField, test as object);
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
}
else
{
sourceFeatureLocal.set_Value(sourceField, test as object);
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
}
}
}
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14al"));
}
finally
{
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14am") + sourceFieldName);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14am") + sourceFieldName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14b") + sourceLayerName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14c") + sourceLayerName);
}
}
}
if (found)
{
break;
}
}
}
fLocalCursor = null;
sourceFeatureLocal = null;
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "UPDATE_INTERSECTING_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "UPDATE_INTERSECTING_FEATURE");
}
break;
}
case "MULTI_FIELD_INTERSECT":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "MULTI_FIELD_INTERSECT");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
// Parse arguments
args = valData.Split('|');
int popFldIdx = 0;
if (args.GetLength(0) > 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain114"));
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString().Trim();
string[] fieldsToPop = args[2].ToString().Split(',');
if (args.GetLength(0) == 4)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain129"));
if (Globals.IsDouble(args[3]))
{
searchDistance = Convert.ToDouble(args[3]);
}
else
{
searchDistance = 0.0;
}
}
else
{
searchDistance = 0.0;
}
if (sourceFieldName != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain130"));
for (int i = 0; i < sourceLayerNames.Length; i++)
{
if (fieldsToPop.Length == popFldIdx)
break;
sourceLayerName = sourceLayerNames[i].ToString().Trim();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0].Trim();
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
sourceField = Globals.GetFieldIndex(sourceLayer.FeatureClass.Fields, sourceFieldName);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
while ((sourceFeature = fCursor.NextFeature()) != null)
{
if (sourceFeature.Class != inFeature.Class)
{
if (fieldsToPop.Length == popFldIdx)
break;
string test = sourceFeature.get_Value(sourceField).ToString().Trim();
int tempFieldNum = Globals.GetFieldIndex(inObject.Fields, fieldsToPop[popFldIdx]);
popFldIdx++;
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, sourceFeature.get_Value(sourceField));
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
if (fieldsToPop.Length == popFldIdx)
break;
string test = sourceFeature.get_Value(sourceField).ToString().Trim();
int tempFieldNum = Globals.GetFieldIndex(inObject.Fields, fieldsToPop[popFldIdx]);
popFldIdx++;
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, sourceFeature.get_Value(sourceField));
}
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14am") + sourceFieldName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14f") + sourceLayerName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14c") + sourceLayerName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14e"));
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14az"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ba"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "MULTI_FIELD_INTERSECT: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "MULTI_FIELD_INTERSECT");
}
break;
case "INTERSECT_STATS":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "INTERSECT_STATS");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int AverageCount = 0;
if (args.GetLength(0) > 2)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain114"));
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString().Trim();
string statType = args[2].ToString().Trim();
if (args.GetLength(0) == 4)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain129"));
if (Globals.IsDouble(args[3]))
searchDistance = Convert.ToDouble(args[3]);
else
searchDistance = 0.0;
}
else
{
searchDistance = 0.0;
}
double result = -999999.1;
string textRes = "";
if (sourceFieldName != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain130"));
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString().Trim();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0].Trim();
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
sourceField = Globals.GetFieldIndex(sourceLayer.FeatureClass.Fields, sourceFieldName);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
if (sourceFeature.Class != inFeature.Class)
{
string test = sourceFeature.get_Value(sourceField).ToString().Trim();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14d") + test);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
string test = sourceFeature.get_Value(sourceField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14d") + test);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
sourceFeature = fCursor.NextFeature();
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14am") + sourceFieldName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14f") + sourceLayerName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14c") + sourceLayerName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14e"));
}
}
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aj") + ex.Message);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14az"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ba"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "INTERSECT_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "INTERSECT_STATS");
}
break;
case "FEATURE_STATS":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "FEATURE_STATS");
if (inFeature != null & valData != null)
{
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int AverageCount = 0;
if (args.GetLength(0) > 1)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain114"));
string[] sourceFieldNames = args[0].ToString().Split(',');
string statType = args[1].ToString();
double result = -999999.1;
string textRes = "";
if (sourceFieldNames != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain131"));
for (int i = 0; i < sourceFieldNames.Length; i++)
{
sourceFieldName = sourceFieldNames[i].ToString();
if (sourceFieldName != "")
{
sourceField = Globals.GetFieldIndex(inObject.Fields, sourceFieldName);
if (sourceField > -1)
{
string test = inObject.get_Value(sourceField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14d") + test);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ai") + test);
break;
}
}
}
}
}
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aj") + ex.Message);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14az"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14ba"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "FEATURE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "FEATURE_STATS");
}
break;
case "INTERSECTING_EDGE":
try
{
if (valData == null) break;
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1:
sourceFieldName = args[0].ToString();
break;
case 2:
sourceFieldName = args[1].ToString();
break;
default: break;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "INTERSECTING_EDGE");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain132"));
if (netFeat != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain103"));
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain104"));
iJuncFeat = (IJunctionFeature)netFeat;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain105") + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain113"));
juncField = Globals.GetFieldIndex(pRow.Fields, sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain133") + test);
inObject.set_Value(intFldIdxs[0], test);
continue;
}
catch
{
}
}//end loop
try
{
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14aj") + ex.Message);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bi"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bj"));
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bk"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "INTERSECTING_EDGE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "INTERSECTING_EDGE");
}
break;
case "INTERSECTING_FEATURE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "INTERSECTING_FEATURE");
if (inFeature != null & valData != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain134"));
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain135") + valData);
// Parse arguments
args = valData.Split('|');
//if (args.GetLength(0) >= 2)
if (args.Length >= 2)
{
AAState.intersectOptions strOpt = AAState.intersectOptions.First;
switch (args.Length)
{
case 2:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
break;
case 3:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
switch (args[2].ToString().ToUpper())
{
case "PROMPT":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "P":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "CENTROID":
strOpt = AAState.intersectOptions.Centroid;
break;
case "C":
strOpt = AAState.intersectOptions.Centroid;
break;
case "F":
strOpt = AAState.intersectOptions.First;
break;
case "L":
strOpt = AAState.intersectOptions.Last;
break;
case "FIRST":
strOpt = AAState.intersectOptions.First;
break;
}
break;
default: break;
}
if (sourceFieldName != null)
{
List<Globals.OptionsToPresent> pFoundFeat = new List<Globals.OptionsToPresent>();
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString().Trim();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0].Trim();
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
// Get layer
if (sourceLayer != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain136") + sourceLayer.Name);
sourceField = Globals.GetFieldIndex(sourceLayer.FeatureClass.Fields, sourceFieldName);
AAState.WriteLine(" " + sourceFieldName + ": at " + sourceField);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, strOpt == AAState.intersectOptions.Centroid);
if (sFilter == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain137"));
continue;
}
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain138"));
if (pFS.SelectionSet.Count > 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain139"));
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain140"));
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain141"));
fCursor = sourceLayer.Search(sFilter, true);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain140"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain142"));
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain140"));
}
if (fCursor == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain143"));
continue;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain144"));
while ((sourceFeature = fCursor.NextFeature()) != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain145"));
if (sourceFeature.Class != inFeature.Class)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain146"));
if (strOpt == AAState.intersectOptions.PromptMulti)
{
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(Globals.GetFieldIndex(sourceFeature.Fields, sourceLayer.DisplayField)).ToString();
pOp.Value = sourceFeature.get_Value(sourceField);
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display + " value = " + pOp.Value.ToString();
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID + " value = " + pOp.Value.ToString();
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
}
else if (strOpt == AAState.intersectOptions.Last)
{
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(Globals.GetFieldIndex(sourceFeature.Fields, sourceLayer.DisplayField)).ToString();
pOp.Value = sourceFeature.get_Value(sourceField);
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display + " value = " + pOp.Value.ToString();
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID + " value = " + pOp.Value.ToString();
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
}
else
{
string test = sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain147") + test);
inObject.set_Value(intFldIdxs[0], sourceFeature.get_Value(sourceField));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
found = true;
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain148"));
if (strOpt == AAState.intersectOptions.PromptMulti)
{
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(Globals.GetFieldIndex(sourceFeature.Fields, sourceLayer.DisplayField)).ToString();
pOp.Value = sourceFeature.get_Value(sourceField);
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display + " value = " + pOp.Value.ToString();
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID + " value = " + pOp.Value.ToString();
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
}
else if (strOpt == AAState.intersectOptions.Last)
{
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(Globals.GetFieldIndex(sourceFeature.Fields, sourceLayer.DisplayField)).ToString();
pOp.Value = sourceFeature.get_Value(sourceField);
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display + " value = " + pOp.Value.ToString();
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID + " value = " + pOp.Value.ToString();
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
}
else
{
string test = sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain147") + test);
inObject.set_Value(intFldIdxs[0], sourceFeature.get_Value(sourceField));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
found = true;
}
}
if (found == true)
break;
}
if (found == false && AAState._CheckEnvelope && pFoundFeat.Count == 0)
{
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
if (strOpt == AAState.intersectOptions.PromptMulti)
{
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(Globals.GetFieldIndex(sourceFeature.Fields, sourceLayer.DisplayField)).ToString();
pOp.Value = sourceFeature.get_Value(sourceField);
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display + " value = " + pOp.Value.ToString();
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID + " value = " + pOp.Value.ToString();
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
}
else if (strOpt == AAState.intersectOptions.Last)
{
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(Globals.GetFieldIndex(sourceFeature.Fields, sourceLayer.DisplayField)).ToString();
pOp.Value = sourceFeature.get_Value(sourceField);
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display + " value = " + pOp.Value.ToString();
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID + " value = " + pOp.Value.ToString();
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
}
else
{
if (found)
{
break;
}
string test = sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain147") + test);
inObject.set_Value(intFldIdxs[0], sourceFeature.get_Value(sourceField));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
found = true;
}
sourceFeature = fCursor.NextFeature();
}
}
if (found)
{
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14am") + sourceFieldName);
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14c") + sourceLayerName);
}
}
}
if (pFoundFeat.Count > 0 && strOpt == AAState.intersectOptions.PromptMulti)
{
Globals.OptionsToPresent strRetVal = Globals.showOptionsForm(pFoundFeat, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain149") + sourceFieldName, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain149") + sourceFieldName, ComboBoxStyle.DropDownList);
if (strRetVal != null)
{
//sourceFeature = sourceLayer.FeatureClass.GetFeature(strRetVal.OID);
string test = strRetVal.Value.ToString();//sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain147") + test);
inObject.set_Value(intFldIdxs[0], strRetVal.Value);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
found = true;
}
}
else if (pFoundFeat.Count > 0 && strOpt == AAState.intersectOptions.Last)
{
//sourceFeature = sourceLayer.FeatureClass.GetFeature(pFoundFeat[pFoundFeat.Count - 1].OID);
string test = pFoundFeat[pFoundFeat.Count - 1].Value.ToString(); //sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain147") + test);
inObject.set_Value(intFldIdxs[0], pFoundFeat[pFoundFeat.Count - 1].Value);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
found = true;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain150"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain151"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain152"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "INTERSECTING_FEATURE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "INTERSECTING_FEATURE");
}
break;
case "INTERSECTING_BOOLEAN":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "INTERSECTING_BOOLEAN");
if (inFeature != null & valData != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain134"));
sourceLayerName = "";
string valTrue = "";
string valFalse = "";
found = false;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain135") + valData);
// Parse arguments
args = valData.Split('|');
//if (args.GetLength(0) >= 2)
if (args.Length == 3)
{
AAState.intersectOptions strOpt = AAState.intersectOptions.First;
switch (args.Length)
{
case 3:
sourceLayerNames = args[0].ToString().Split(',');
valTrue = args[1].ToString();
valFalse = args[2].ToString();
break;
default: break;
}
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString().Trim();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0].Trim();
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
// Get layer
if (sourceLayer != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain136") + sourceLayer.Name);
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, strOpt == AAState.intersectOptions.Centroid);
if (sFilter == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain137"));
continue;
}
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain138"));
if (pFS.SelectionSet.Count > 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain139"));
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain140"));
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain141"));
fCursor = sourceLayer.Search(sFilter, true);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain140"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain142"));
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain140"));
}
if (fCursor == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain143"));
continue;
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain144"));
while ((sourceFeature = fCursor.NextFeature()) != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain145"));
if (sourceFeature.Class != inFeature.Class)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain146"));
found = true;
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain148"));
found = true;
}
if (found == true)
break;
}
if (found == false && AAState._CheckEnvelope)
{
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
found = true;
break;
}
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14c") + sourceLayerName);
}
if (found)
{
break;
}
}
else
{
AAState.WriteLine(" " + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14a") + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorWarn_14c") + sourceLayerName);
}
}
if (found)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain147") + valTrue);
inObject.set_Value(intFldIdxs[0], valTrue);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain147") + valFalse);
inObject.set_Value(intFldIdxs[0], valFalse);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14az"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain153"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain154"));
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "INTERSECTING_BOOLEAN: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "INTERSECTING_BOOLEAN");
}
break;
case "INTERSECTING_RASTER":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "INTERSECTING_RASTER");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
formatString = "";
found = false;
// Parse arguments
args = valData.Split('|');
if (args.Length < 1) break;
switch (args.Length)
{
case 1:
sourceLayerNames = args[0].ToString().Split(',');
break;
case 2:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
break;
default: break;
}
// Get layer
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString().Trim();
IPoint pLoc = Globals.GetGeomCenter(inFeature)[0];
if (pLoc != null)
{
string cellVal = Globals.GetCellValue(sourceLayerName, pLoc, AAState._editor.Map);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain155") + sourceLayerName);
if (cellVal != null && cellVal != "" && cellVal != "No Raster")
{
if (formatString == null || formatString == "" || (inObject.Fields.get_Field(intFldIdxs[0]).Type != esriFieldType.esriFieldTypeString))
{
inObject.set_Value(intFldIdxs[0], cellVal);
found = true;
break;
}
else
{
formatString = formatString + cellVal;
inObject.set_Value(intFldIdxs[0], formatString);
found = true;
break;
}
}
}
}
if (!(found) && inObject.Fields.get_Field(intFldIdxs[0]).IsNullable)
inObject.set_Value(intFldIdxs[0], null);
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "INTERSECTING_RASTER: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "INTERSECTING_RASTER");
}
break;
case "INTERSECTING_LAYER_DETAILS":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "INTERSECTING_LAYER_DETAILS");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
formatString = "";
found = false;
List<string> matchPattern = null;
// Parse arguments
args = valData.Split('|');
if (args.Length >= 1)
{
AAState.intersectOptions strOpt = AAState.intersectOptions.First;
switch (args.Length)
{
case 1:
sourceLayerNames = args[0].ToString().Split(',');
formatString = "P";
break;
case 2:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
break;
case 3:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
switch (args[2].ToString().ToUpper())
{
case "PROMPT":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "P":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "CENTROID":
strOpt = AAState.intersectOptions.Centroid;
break;
case "C":
strOpt = AAState.intersectOptions.Centroid;
break;
case "F":
strOpt = AAState.intersectOptions.First;
break;
case "FIRST":
strOpt = AAState.intersectOptions.First;
break;
}
break;
case 4:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
switch (args[2].ToString().ToUpper())
{
case "PROMPT":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "P":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "CENTROID":
strOpt = AAState.intersectOptions.Centroid;
break;
case "C":
strOpt = AAState.intersectOptions.Centroid;
break;
case "F":
strOpt = AAState.intersectOptions.First;
break;
case "FIRST":
strOpt = AAState.intersectOptions.First;
break;
}
matchPattern = new List<string>(args[3].ToString().Split(','));
break;
default: break;
}
List<Globals.OptionsToPresent> strFiles = new List<Globals.OptionsToPresent>();
// Get layer
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString().Trim();
IGeometry pGeo = inFeature.ShapeCopy;
List<IGeometry> pGeos = new List<IGeometry>();
if (pGeo != null)
{
if (strOpt == AAState.intersectOptions.Centroid)
{
List<IPoint> pGeoPnts = Globals.GetGeomCenter(pGeo);
pGeos = pGeoPnts.ConvertAll(new Converter<IPoint, IGeometry>(Globals.PointToGeometry));
}
else
{
pGeos.Add(pGeo);
}
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain156") + sourceLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain157"));
IEnumLayer pEnum = Globals.GetLayers(AAState._editor.Map, sourceLayerName);
if (pEnum != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain158") + sourceLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain157"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain159"));
ILayer pLay = pEnum.Next();
while (pLay != null)
{
intersectLayerDetailsFunctions(pLay, pGeos, strOpt, ref found, ref strFiles, ref inObject, intFldIdxs[0], matchPattern);
if (found)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain160"));
break;
}
pLay = pEnum.Next();
}
pLay = null;
pEnum = null;
}
else
{
bool FCorLayerTemp = true;
ILayer pLay = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref FCorLayerTemp);
if (pLay != null)
{
intersectLayerDetailsFunctions(pLay, pGeos, strOpt, ref found, ref strFiles, ref inObject, intFldIdxs[0], matchPattern);
}
pLay = null;
}
if (pEnum != null)
Marshal.ReleaseComObject(pEnum);
pEnum = null;
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain161"));
}
if (found)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain160"));
break;
}
pGeo = null;
pGeos = null;
}
if (strOpt == AAState.intersectOptions.PromptMulti && strFiles.Count > 0)
{
Globals.OptionsToPresent strRetVal = Globals.showOptionsForm(strFiles, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain162") + strFldNames[0], A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain163") + strFldNames[0], ComboBoxStyle.DropDownList);
if (strRetVal != null)
{
try
{
inObject.set_Value(intFldIdxs[0], strRetVal.Display);
}
catch
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain164"));
}
found = true;
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain165"));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "INTERSECTING_LAYER_DETAILS: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "INTERSECTING_LAYER_DETAILS");
}
break;
case "INTERSECTING_FEATURE_DISTANCE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "INTERSECTING_FEATURE_DISTANCE");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
// Parse arguments
args = valData.Split('|');
if (args.GetLength(0) >= 2)
{
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString().Trim();
}
// Get layer
if (sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
sourceLayerName = args[i].ToString();
if (i == 0)
i++;
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer == null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14b") + sourceLayerName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
continue;
}
IFeatureClass iFC = inFeature.Class as IFeatureClass;
if (sourceLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayer + " is a polygon layer");
break;
}
if (sourceLayer != null)
{
sourceField = Globals.GetFieldIndex(sourceLayer.FeatureClass.Fields, sourceFieldName);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
while ((sourceFeature = fCursor.NextFeature()) != null)
{
if (sourceFeature.Class != inFeature.Class)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
IPoint snapPnt = null;
double dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
snapPnt = null;
string strUnit = Globals.GetSpatRefUnitName(Globals.GetLayersCoordinateSystem(sourceLayer.FeatureClass), true);
if (strUnit == "Foot" && dAlong != 1)
{
strUnit = "Feet";
}
else if (strUnit == "Meter" && dAlong != 1)
{
strUnit = "Meters";
}
string strDis = dAlong + " " + strUnit + " along " + sourceLayer.Name + " with " + sourceLayer.FeatureClass.Fields.get_Field(sourceField).AliasName + A4LGSharedFunctions.Localizer.GetString("Of") + sourceFeature.get_Value(sourceField);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong + " " + strUnit + ": " + sourceFeature.get_Value(sourceField);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain166") + strDis);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
else
{
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
else
{
strDis = dAlong.ToString();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain166") + strDis);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
else
{
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain167") + strDis);
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
IPoint snapPnt = null;
double dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
snapPnt = null;
string strUnit = Globals.GetSpatRefUnitName(Globals.GetLayersCoordinateSystem(sourceLayer.FeatureClass), true);
if (strUnit == "Foot" && dAlong != 1)
{
strUnit = "Feet";
}
else if (strUnit == "Meter" && dAlong != 1)
{
strUnit = "Meters";
}
string strDis = dAlong + " " + strUnit + " along " + sourceLayer.Name + " with " + sourceLayer.FeatureClass.Fields.get_Field(sourceField).AliasName + A4LGSharedFunctions.Localizer.GetString("Of") + sourceFeature.get_Value(sourceField);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong + " " + strUnit + ": " + sourceFeature.get_Value(sourceField);
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain166") + strDis);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
else
{
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
else
{
strDis = dAlong.ToString();
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain166") + strDis);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
else
{
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain167") + strDis);
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayer + ": field: " + sourceFieldName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else { }
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "INTERSECTING_FEATURE_DISTANCE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "INTERSECTING_FEATURE_DISTANCE");
}
break;
//Release: 1.2
//New Dynamic Value Method: NEARSET_FEATURE - similiar to INTERSECTING_FEATURE but requires a search distance.
case "NEAREST_FEATURE":
try
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ar") + "NEAREST_FEATURE");
if (inFeature != null & valData != null)
{
string sourceMatField = "";
string targetMatField = "";
sourceLayerName = "";
sourceFieldName = "";
searchDistance = 0;
found = false;
// Parse arguments
args = valData.Split('|');
switch (args.Length)
{
case 2:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
break;
case 3:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
Double.TryParse(args[2], out searchDistance);
break;
case 4:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain168"));
break;
case 5:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
Double.TryParse(args[2], out searchDistance);
sourceMatField = args[3].ToString();
targetMatField = args[4].ToString();
break;
default:
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain168"));
break;
}
if (sourceLayerNames.Length > 0 & sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
bool FCorLayerSource = true;
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref FCorLayerSource) as IFeatureLayer;
if (sourceLayer != null)
{
sourceField = Globals.GetFieldIndex(sourceLayer.FeatureClass.Fields, sourceFieldName);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain169"));
if (pFS.SelectionSet.Count > 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain170"));
pFS.SelectionSet.Search(sFilter, false, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, false);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain171"));
fCursor = sourceLayer.FeatureClass.Search(sFilter, false);
}
nearestFeature = null;
proxOp = (IProximityOperator)inFeature.ShapeCopy;
lastDistance = searchDistance;
while ((sourceFeature = fCursor.NextFeature()) != null)
{
if (sourceFeature.Class != inFeature.Class)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain172"));
if (targetMatField == "" && sourceMatField == "")
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain173"));
try
{
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
pTempGeo = null;
}
catch
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain174"));
return false;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain175"));
int idxTargetFld = Globals.GetFieldIndex(sourceLayer, targetMatField);
int idxSourceFld = Globals.GetFieldIndex(inObject.Fields, sourceMatField);
if (idxSourceFld >= 0 && idxTargetFld >= 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain176"));
if (inObject.get_Value(idxSourceFld).ToString() == sourceFeature.get_Value(idxTargetFld).ToString())
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
pTempGeo = null;
}
else
{
AAState.WriteLine(" Values does not Match: " + inObject.get_Value(idxSourceFld).ToString() + " - " + sourceFeature.get_Value(idxTargetFld).ToString());
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain177"));
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
pTempGeo = null;
}
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain175"));
int idxTargetFld = Globals.GetFieldIndex(sourceLayer, targetMatField);
int idxSourceFld = Globals.GetFieldIndex(inObject.Fields, sourceMatField);
if (idxSourceFld >= 0 && idxTargetFld >= 0)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain176"));
if (inObject.get_Value(idxSourceFld).ToString() == sourceFeature.get_Value(idxTargetFld).ToString())
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14ay"));
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
pTempGeo = null;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain177"));
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
pTempGeo = null;
}
}
}
if (nearestFeature != null)
{
AAState.WriteLine(" Feature found: " + nearestFeature.Class.AliasName + ":" + nearestFeature.OID);
inObject.set_Value(intFldIdxs[0], nearestFeature.get_Value(sourceField));
found = true;
break;
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayer + ": field: " + sourceFieldName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + sourceLayer + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14bb"));
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain178"));
}
}
if (!found)
{
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorError_14a") + "NEAREST_FEATURE: " + ex.Message);
}
finally
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14as") + "NEAREST_FEATURE");
}
break;
default:
AAState.WriteLine("ERROR: " + valMethod + " for layer " + tableName + " is not a valid method, check the dynamic value table");
break;
}
}
catch (Exception ex)
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain179") + tableName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain180") + strFldNames[0] + System.Environment.NewLine + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain181") + valMethod + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain182") + valData + System.Environment.NewLine + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain183") + ex.Message, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain184"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain185") + tableName + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain180") + strFldNames[0] + System.Environment.NewLine + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain181") + valMethod + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain182") + valData + System.Environment.NewLine + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain183") + ex.Message);
}
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain186"));
}
try
{
if (intFldIdxs.Count > 0 && strFldNames.Count > 0)
{
for (int p = 0; p < strFldNames.Count; p++)
{
IRowChanges inChanges = inObject as IRowChanges;
bool changed = inChanges.get_ValueChanged(intFldIdxs[p]);
if (changed)
try
{
if (AAState.lastValueProperties.GetProperty(strFldNames[p]) != null)
{
LastValueEntry lstVal = AAState.lastValueProperties.GetProperty(strFldNames[p]) as LastValueEntry;
if (lstVal != null)
{
if (mode == "ON_CREATE" && lstVal.On_Create == false)
{
string test = "";
}
else if (mode == "ON_MANUAL" && lstVal.On_Manual == false)
{
string test = "";
}
else if (mode == "ON_CHANGE" && lstVal.On_ChangeAtt == false)
{
string test = "";
}
else if (mode == "ON_CHANGEGEO" && lstVal.On_ChangeGeo == false)
{
string test = "";
}
else
{
if (lstVal.Value != null)
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14p") );
if (mode == "ON_CREATE" && (inObject.get_Value(intFldIdxs[p]) == null || inObject.get_Value(intFldIdxs[p]).ToString() == ""))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain187"));
}
else
{
AAState.WriteLine(" " + strFldNames[p] + ": " + inObject.get_Value(intFldIdxs[p]).ToString());
lstVal.Value = inObject.get_Value(intFldIdxs[p]);
AAState.lastValueProperties.SetProperty(strFldNames[p], lstVal);
}
}
else
{
if (mode == "ON_CREATE" && (inObject.get_Value(intFldIdxs[p]) == null || inObject.get_Value(intFldIdxs[p]).ToString() == ""))
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain187"));
}
else
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorMess_14p") );
AAState.WriteLine(" " + strFldNames[p] + ": " + inObject.get_Value(intFldIdxs[p]).ToString());
lstVal.Value = inObject.get_Value(intFldIdxs[p]);
AAState.lastValueProperties.SetProperty(strFldNames[p], lstVal);
}
}
}
}
}
}
catch
{
}
}
}
}
catch
{
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain188"));
}
AAState.WriteLine(" ------------------------------------------------");
}
}
}
return true;
}
catch (Exception ex)
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain189") + System.Environment.NewLine + A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain190") + ex.Message, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain184"));
AAState.WriteLine(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain189"));
return false;
}
finally
{
if (AAState._tab == inObject.Class || AAState._gentab == inObject.Class)
{
AAState.reInitExt();
}
//if (progressDialog != null)
//{
// progressDialog.HideDialog();
//}
AAState.WriteLine("DONE");
AAState.WriteLine("---------------------------------------");
if (fCursor != null)
{
Marshal.ReleaseComObject(fCursor);
GC.Collect(300);
GC.WaitForFullGCComplete();
}
inFeature = null;
mseg = null;
netFeat = null;
iEdgeFeat = null;
iJuncFeat = null;
//progressDialogFactory = null;
//stepProgressor = null;
//progressDialog = null;
//trackCancel = null;
ArcMap.Application.StatusBar.set_Message(0, A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain191"));
}
}
private void SearchFeature(ISpatialFilter pSpatialFilter, IFeatureLayer pFeatureLyr)
{
ISpatialFilter pFilter;
pFilter = pSpatialFilter;
IFeatureLayer pFeatureLayer;
pFeatureLayer = pFeatureLyr;
IFeatureClass pFC = pFeatureLayer.FeatureClass;
IFeatureCursor pFeatureCursor;
pFeatureCursor = pFeatureLayer.Search(pFilter, true);
IFeature pFeature;
pFeature = pFeatureCursor.NextFeature();
IGeometry pShape;
switch (pFC.ShapeType)
{
case esriGeometryType.esriGeometryPolyline:
while (pFeature != null)
{
ISimpleLineSymbol pFillsyl;
pFillsyl = new SimpleLineSymbolClass();
pFillsyl.Color = getRGB(220, 100, 50);
object oFillsyl;
oFillsyl = pFillsyl;
pShape = pFeature.Shape as IPolyline;
m_mapControl.FlashShape(pShape, 15, 20, pFillsyl);
m_mapControl.DrawShape(pShape, ref oFillsyl);
pFeature = pFeatureCursor.NextFeature();
}
break;
case esriGeometryType.esriGeometryPolygon:
while (pFeature != null)
{
ISimpleFillSymbol pFillsyl;
pFillsyl = new SimpleFillSymbolClass();
pFillsyl.Color = getRGB(220, 100, 50);
object oFillsyl;
oFillsyl = pFillsyl;
pShape = pFeature.Shape as IPolygon;
m_mapControl.FlashShape(pShape, 15, 20, pFillsyl);
m_mapControl.DrawShape(pShape, ref oFillsyl);
pFeature = pFeatureCursor.NextFeature();
}
break;
case esriGeometryType.esriGeometryPoint:
while (pFeature != null)
{
ISimpleMarkerSymbol pFillsyl;
pFillsyl = new SimpleMarkerSymbolClass();
pFillsyl.Color = getRGB(220, 100, 50);
object oFillsyl;
oFillsyl = pFillsyl;
pShape = pFeature.Shape as IPoint;
m_mapControl.FlashShape(pShape, 15, 20, pFillsyl);
m_mapControl.DrawShape(pShape, ref oFillsyl);
pFeature = pFeatureCursor.NextFeature();
}
break;
}
}
public void SetDynamicValues(IObject inObject, string mode)
{
IFeature inFeature = null;
// IRow inRow = null;
IMSegmentation mseg = null;
INetworkFeature netFeat = null;
IEdgeFeature edgeFeat = null;
IFeature juncFeat;
IJunctionFeature iJuncFeat;
//ProgressBar
ESRI.ArcGIS.Framework.IProgressDialogFactory progressDialogFactory = null;
ESRI.ArcGIS.esriSystem.IStepProgressor stepProgressor = null;
ESRI.ArcGIS.Framework.IProgressDialog2 progressDialog = null;
// Create a CancelTracker
ESRI.ArcGIS.esriSystem.ITrackCancel trackCancel = new ESRI.ArcGIS.Display.CancelTrackerClass();
try
{
if (AAState._PerformUpdates && AAState._dv == null)
{
AAState.WriteLine("Dynamic Value Table is missing - Name in Config:" + AAState._defaultsTableName);
// MessageBox.Show("The Attribute Assistant is turned on, but the Dynamic Value table is missing, please add the table and toggle the extension on");
AAState._PerformUpdates = false;
return;
}
if (AAState._PerformUpdates && AAState._dv != null)
{
if (inObject == null)
return;
//Convert row to feature (test for feature is null before using - this could be a table update)
inFeature = inObject as IFeature;
// inRow = inObject as IRow;
string modeVal;
if (AAState._dv.Table.Columns[mode].DataType == System.Type.GetType("System.String"))
{
modeVal = "(" + mode + " = '1' or " + mode + " = 'Yes' or " + mode + " = 'YES' or " + mode + " = 'True' or " + mode + " = 'TRUE')";
}
else
{
modeVal = mode + " = 1";
}
System.Int32 int32_hWnd = ArcMap.Application.hWnd;
progressDialogFactory = new ESRI.ArcGIS.Framework.ProgressDialogFactoryClass();
stepProgressor = progressDialogFactory.Create(trackCancel, int32_hWnd);
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = inObject.Fields.FieldCount;
stepProgressor.StepValue = 1;
stepProgressor.Message = "Attribute Assistant Progress";
// Create the ProgressDialog. This automatically displays the dialog
progressDialog = (ESRI.ArcGIS.Framework.IProgressDialog2)stepProgressor; // Explict Cast
// Set the properties of the ProgressDialog
progressDialog.CancelEnabled = true;
progressDialog.Description = "Checking rules for " + inObject.Class.AliasName;
progressDialog.Title = "Attribute Assistant Progress";
progressDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressGlobe;
progressDialog.ShowDialog();
//for each field in this row/feature
// Skip orphan junctions (saves time)
if (Globals.isOrpanJunction(inFeature))
return;
//Get table name for this feature
_currentDataset = inObject.Class as IDataset;
_currentDatasetNameItems = _currentDataset.Name.Split('.');
tableName = _currentDatasetNameItems[_currentDatasetNameItems.GetLength(0) - 1];
for (int fieldNum = 0; fieldNum <= inObject.Fields.FieldCount; fieldNum++)
{
stepProgressor.Step();
bool editable = true;
if (fieldNum == inObject.Fields.FieldCount)
{
fieldObj = null;
fieldName = "";
stepProgressor.Message = "Checking rules for field null fields in" + inObject.Class.AliasName;
progressDialog.Description = "Checking rules for field null fields in" + inObject.Class.AliasName;
AAState.WriteLine("***********************************************************");
AAState.WriteLine("");
AAState.WriteLine("############ " + DateTime.Now + " ################");
editable = true;
// fieldNum++;
}
else
{
fieldObj = inObject.Fields.get_Field(fieldNum);
fieldName = fieldObj.Name;
stepProgressor.Message = "Checking rules for field " + fieldName + " in " + inObject.Class.AliasName;
progressDialog.Description = "Checking rules for field " + fieldName + " in " + inObject.Class.AliasName;
AAState.WriteLine("***********************************************************");
AAState.WriteLine("");
AAState.WriteLine("############ " + fieldName + " ################");
AAState.WriteLine("############ " + DateTime.Now + " ################");
AAState.WriteLine("Is field - " + fieldName + " Editable = " + fieldObj.Editable);
editable = fieldObj.Editable;
}
bool proc = false;
if (editable == true && fieldObj != null)
{
AAState.WriteLine("Checking rules for field " + fieldName + " in " + inObject.Class.AliasName);
AAState._dv.RowFilter = "(TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And FIELDNAME = '" + fieldName + "' and " + modeVal;
//AAState._dv.rw
AAState.WriteLine(" Row Query: " + "TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And FIELDNAME = '" + fieldName + "' and " + modeVal);
if (AAState._dv.Count == 0)
{
AAState._dv.RowFilter = "TABLENAME = '*' And FIELDNAME = '" + fieldName + "' and " + modeVal;
AAState.WriteLine(" Query using " + fieldName + " did not produce any results, trying all fields");
AAState.WriteLine(" Row Query: " + "TABLENAME = '*' And FIELDNAME = '" + fieldName + "' and " + modeVal);
}
if (AAState._dv.Count == 0)
{
AAState.WriteLine(" No entries found");
proc = false;
}
else
{
proc = true;
}
}
// else if (editable == false )
//{
// AAState.WriteLine("Checking rules for field " + fieldName + " in " + inObject.Class.AliasName);
// AAState._dv.RowFilter = "(TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And FIELDNAME = '" + fieldName + "' and " + modeVal;
// //AAState._dv.rw
// AAState.WriteLine(" Row Query: " + "TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And FIELDNAME = '" + fieldName + "' and " + modeVal);
// if (AAState._dv.Count == 0)
// {
// AAState._dv.RowFilter = "TABLENAME = '*' And FIELDNAME = '" + fieldName + "' and " + modeVal;
// AAState.WriteLine(" Query using " + fieldName + " did not produce any results, trying all fields");
// AAState.WriteLine(" Row Query: " + "TABLENAME = '*' And FIELDNAME = '" + fieldName + "' and " + modeVal);
// }
// if (AAState._dv.Count == 0)
// {
// AAState.WriteLine(" No entries found");
// proc = false;
// }
// else
// {
// proc = true;
// }
//}
else if (editable && fieldObj == null)
{
fieldName = "";
AAState._dv.RowFilter = "(TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And (FIELDNAME = '" + fieldName + "' or FIELDNAME IS NULL) and " + modeVal;
//AAState._dv.rw
AAState.WriteLine(" Row Query: " + "TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And (FIELDNAME = '" + fieldName + "' or FIELDNAME IS NULL) and " + modeVal);
if (AAState._dv.Count == 0)
{
AAState._dv.RowFilter = "TABLENAME = '*' And (FIELDNAME = '" + fieldName + "' or FIELDNAME IS NULL) and " + modeVal;
AAState.WriteLine(" Query using " + fieldName + " did not produce any results, trying all fields");
AAState.WriteLine(" Row Query: " + "TABLENAME = '*' And And (FIELDNAME = '" + fieldName + "' or FIELDNAME IS NULL) and " + modeVal);
}
if (AAState._dv.Count == 0)
{
AAState.WriteLine(" No entries found");
proc = false;
}
else
{
proc = true;
}
}
if (proc)
{
AAState.WriteLine(" Value Entry Rows found: " + AAState._dv.Count);
AAState.WriteLine(" ----------------------------------------------");
// Get requested method and any data parameters
AAState.WriteLine(" Looping through Value Methods");
AAState.WriteLine(" ------------------------");
foreach (DataRowView drv in AAState._dv)
{
AAState.WriteLine(" Checking for Subtype Restriction");
valFC = drv["TABLENAME"].ToString().Trim();
if (valFC.Contains("|"))
{
AAState.WriteLine(" Subtype restriction Found");
string[] spliVal = valFC.Split('|');
if (Globals.IsInteger(spliVal[1]))
{
int SubVal = Convert.ToInt32(spliVal[1]);
ISubtypes pSub = inObject.Class as ISubtypes;
if (pSub != null)
{
if (pSub.HasSubtype)
{
int obSubVal = (int)inObject.get_Value(pSub.SubtypeFieldIndex);
if (obSubVal == SubVal)
{
AAState.WriteLine(" Subtypes match");
}
else
{
AAState.WriteLine(" Skipping, not the subtype defined");
continue;
}
}
else
{
AAState.WriteLine(" ERROR: Layer does not have subtypes");
}
}
else
{
AAState.WriteLine(" ERROR: Layer does not have subtypes");
}
}
else
{
AAState.WriteLine(" ERROR: Subtype not an integar");
}
}
valMethod = drv["VALUEMETHOD"].ToString().ToUpper().Trim();
valData = drv["VALUEINFO"].ToString().Trim();
AAState.WriteLine(" VALUEMETHOD: " + valMethod);
AAState.WriteLine(" VALUEINFO: " + valData);
AAState.WriteLine(" ------------------------");
//set field value based on specified method
try
{
switch (valMethod)
{
case "SPLIT_INTERSECTING_FEATURE":
{
AAState.WriteLine(" Trying: SPLIT_INTERSECTING_FEATURE");
try
{
if ((valData != null) && (inFeature != null))
{
intersectLayerName = "";
intersectLayer = null;
args = valData.Split('|');
if (args.Length > 0)
{
AAState.WriteLine(" " + args.Length + " Layers listed ");
for (int i = 0; i < args.Length; i++)
{
intersectLayerName = args[i].Trim();
AAState.WriteLine(" Searching for " + intersectLayerName);
intersectLayer = Globals.FindLayer(AAState._editor.Map, intersectLayerName) as IFeatureLayer;
if (intersectLayer != null)
{
AAState.WriteLine(" Layer Found " + intersectLayerName);
if (intersectLayer.FeatureClass != null)
{
AAState.WriteLine(" Datasource is valid for " + intersectLayerName);
sFilter = new SpatialFilterClass();
AAState.WriteLine(" Checking source Geometry Type");
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
// esriSpatialRelIntersects does not work properly for point intersecting line.
// hence expand point envelope (code cribbed from below)
try
{
ISpatialReferenceResolution pSRResolution;
pSRResolution = ((sourceLayer.FeatureClass as IGeoDataset).SpatialReference) as ISpatialReferenceResolution;
// sFilter = new SpatialFilterClass();
double intTol = pSRResolution.get_XYResolution(false);
bool hasXY = ((sourceLayer.FeatureClass as IGeoDataset).SpatialReference).HasXYPrecision();
searchEnvelope = new EnvelopeClass();
searchEnvelope.XMin = 0 - intTol;
searchEnvelope.YMin = 0 - intTol;
searchEnvelope.XMax = 0 + intTol;
searchEnvelope.YMax = 0 + intTol;
searchEnvelope.CenterAt(inFeature.ShapeCopy as IPoint);
//searchEnvelope.SpatialReference = ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference;
searchEnvelope.SpatialReference = ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference;
searchEnvelope.SnapToSpatialReference();
searchEnvelope.Project(AAState._editor.Map.SpatialReference);
sFilter.Geometry = Globals.Env2Polygon(searchEnvelope);
}
catch
{
sFilter.Geometry = inFeature.ShapeCopy;
}
}
else
{
AAState.WriteLine(" Geoemetry is not a point, using shape envelope");
sFilter.Geometry = inFeature.ShapeCopy;
}
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
sFilter.GeometryField = intersectLayer.FeatureClass.ShapeFieldName;
AAState.WriteLine(" Searching " + intersectLayerName + "for intersected feature");
fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
IFeature intsersectFeature;
int idx = 1;
while ((intsersectFeature = fCursor.NextFeature()) != null)
{
AAState.WriteLine(" Splitting Intersected Feature number: " + idx);
idx++;
IFeatureEdit featureEdit = intsersectFeature as IFeatureEdit;
ISet featset = featureEdit.Split(inFeature.Shape);
AAState.WriteLine(" Adding split features to array to call the AA ext");
if (featset.Count > 0)
{
if (newFeatureList == null)
{
newFeatureList = new List<IObject>();
}
object featobj;
while ((featobj = featset.Next()) != null)
{
IFeature feature = featobj as IFeature;
if (feature != null)
{
newFeatureList.Add(feature as IObject);
}
}
}
AAState.WriteLine(" Split feature " + intersectLayerName + " into " + featset.Count);
if (intsersectFeature != null)
{
Marshal.ReleaseComObject(intsersectFeature);
}
}
}
}
else
{
AAState.WriteLine(" Warning: Can't find intersecting layer: " + intersectLayerName);
}
}
}
else
{
AAState.WriteLine(" ERROR: Unsupported Value Info: " + valData);
}
}
else
{
AAState.WriteLine(" ERROR: not a feature or no Value Info");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: SPLIT_INTERSECTING_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: SPLIT_INTERSECTING_FEATURE");
}
break;
}
case "NEAREST_FEATURE_ATTRIBUTES":
{
AAState.WriteLine(" Trying NEAREST_FEATURE_ATTRIBUTES");
try
{
if ((valData != null) && (inFeature != null))
{
sourceLayerName = "";
string[] sourceFieldNames = null;
string[] destFieldNames = null;
searchDistance = 0;
// Parse arguments
args = valData.Split('|');
if (args.Length == 3)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
destFieldNames = args[2].ToString().Split(',');
AAState.WriteLine(" WARNING: search distance as not specified, defaulting to 0");
}
else if (args.Length == 4)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
destFieldNames = args[2].ToString().Split(',');
Double.TryParse(args[3], out searchDistance);
}
else
{
AAState.WriteLine(" ERROR: the valuemethod is not defined properly for this rule");
continue;
}
if ((sourceFieldNames != null) && (destFieldNames != null) &&
(sourceFieldNames.Length > 0) && (destFieldNames.Length > 0) &&
(sourceFieldNames.Length == destFieldNames.Length))
{
AAState.WriteLine(" Looking for layer: " + sourceLayerName);
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName) as IFeatureLayer;
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
AAState.WriteLine(" layer Found: " + sourceLayerName);
string missingFieldMess = null;
int[] sourceFieldNums = new int[sourceFieldNames.Length];
int[] destFieldNums = new int[destFieldNames.Length];
AAState.WriteLine(" Checking Field Mapping");
for (int i = 0; i < sourceFieldNums.Length; i++)
{
int fnum = sourceLayer.FeatureClass.FindField(sourceFieldNames[i].Trim());
if (fnum < 0)
{
missingFieldMess = sourceFieldNames[i].Trim() + " in table " + sourceLayerName;
break;
}
sourceFieldNums[i] = fnum;
}
if (missingFieldMess == null)
{
for (int i = 0; i < destFieldNums.Length; i++)
{
int fnum = inFeature.Fields.FindField(destFieldNames[i].Trim());
if (fnum < 0)
{
missingFieldMess = destFieldNames[i].Trim() + " in table " + tableName;
break;
}
destFieldNums[i] = fnum;
}
}
if (missingFieldMess == null)
{
AAState.WriteLine(" Field Mapping verified");
// found source and destination fields.
sFilter = new SpatialFilterClass();
if (searchDistance > 0)
{
searchEnvelope = inFeature.ShapeCopy.Envelope;
searchEnvelope.Expand(searchDistance, searchDistance, false);
sFilter.Geometry = searchEnvelope;
}
else
sFilter.Geometry = inFeature.ShapeCopy;
sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
AAState.WriteLine(" Searching for Nearest Feature");
fCursor = sourceLayer.FeatureClass.Search(sFilter, false);
sourceFeature = fCursor.NextFeature();
nearestFeature = null;
proxOp = (IProximityOperator)inFeature.Shape;
lastDistance = searchDistance;
if (sourceFeature != null)
{
AAState.WriteLine(" Features Found, looping for closest");
while (sourceFeature != null)
{
distance = proxOp.ReturnDistance(sourceFeature.Shape);
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
sourceFeature = fCursor.NextFeature();
}
}
if (nearestFeature != null)
{
AAState.WriteLine(" Closest Feature is " + lastDistance + " Away with OID of " + nearestFeature.OID);
for (int i = 0; i < sourceFieldNums.Length; i++)
{
try
{
AAState.WriteLine(" Trying to copy " + sourceFieldNums[i] + " to " + destFieldNums[i]);
inObject.set_Value(destFieldNums[i], nearestFeature.get_Value(sourceFieldNums[i]));
}
catch
{
AAState.WriteLine(" ERROR: copying " + sourceFieldNums[i] + " to " + destFieldNums[i]);
}
}
}
else
{
AAState.WriteLine(" No Feature was found, default fields");
for (int i = 0; i < destFieldNums.Length; i++)
{
IField field = inObject.Fields.get_Field(destFieldNums[i]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(destFieldNums[i], null);
}
}
else
{
inObject.set_Value(destFieldNums[i], newval);
}
}
}
}
else
{
AAState.WriteLine(" ERROR: Cant find field " + missingFieldMess);
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " data source is not set");
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " was not found");
}
}
else
{
AAState.WriteLine(" ERROR: Invalid Value Info: " + valData);
}
}
else
{
AAState.WriteLine(" ERROR: Not a feature or missing Value Info");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: EUK_NEAREST_FEATURE_ATTRIBUTES" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: EUK_NEAREST_FEATURE_ATTRIBUTES");
}
break;
}
case "MINIMUM_LENGTH":
{
try
{
AAState.WriteLine(" Trying MINIMUM_LENGTH");
double minlength;
AAState.WriteLine(" Evaluating Minimum length value");
if (Double.TryParse(valData, out minlength))
{
if (inFeature != null)
{
ICurve curve = inFeature.Shape as ICurve;
if (curve != null)
{
if (curve.Length < minlength)
{
String mess = "Line is shorter than " +
String.Format("{0:0.00}", minlength) + " " + Globals.GetSpatRefUnitName(inFeature.Shape.SpatialReference, true) +
", aborting edit.";
AAState.WriteLine(" " + mess);
MessageBox.Show(mess, "Line too short");
AAState._editor.AbortOperation();
return;
}
}
else
{
AAState.WriteLine(" ERROR: Feature is not a Line");
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" Error MINIMUM_LENGTH \n" + ex.Message);
}
finally
{
AAState.WriteLine(" Finished MINIMUM_LENGTH");
}
break;
}
case "LINK_TABLE_ASSET":
try
{
intersectLayerName = "";
intersectTable = null;
intersectLayer = null;
intersectLayerFieldName = "";
AAState.WriteLine(" Trying LINK_TABLE_ASSET");
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // Feature Layer only
intersectLayerName = args[0].ToString();
break;
case 2: // Feature Layer| Field to copy
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
break;
case 3: // Feature Layer| Field to copy | for future
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//sequenceColumnName = args[2].ToString();
break;
default:
AAState.WriteLine(" ERROR: Unsupported Value Method: " + valData);
break;
}
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName);
intersectTable = Globals.FindStandAloneTable(AAState._editor.Map, intersectLayerName);
ICursor cCurs = null;
if (intersectLayer != null)
{
//Find Area Field
intersectFieldPos = intersectLayer.FeatureClass.Fields.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(" ERROR: Asset feature Layer Field(" + intersectLayerFieldName + ") not found");
break;
}
intersectLayerSelection = (IFeatureSelection)intersectLayer;
if (intersectLayerSelection.SelectionSet.Count == 0)
{
AAState.WriteLine(" ERROR: No assests selected in " + intersectLayerName);
break;
}
if (intersectLayerSelection.SelectionSet.Count > 1)
{
AAState.WriteLine(" ERROR: To many assests are selected in " + intersectLayerName);
break;
}
intersectLayerSelection.SelectionSet.Search(null, true, out cCurs);
}
else if (intersectTable != null)
{
if (intersectTable.Table == null)
{
AAState.WriteLine(" ERROR: Asset Layer(" + intersectLayerName + ") not found");
break;
}
//Find Area Field
intersectFieldPos = intersectTable.Table.Fields.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(" ERROR: Asset Layer Field(" + intersectLayerFieldName + ") not found");
break;
}
intersectTableSelection = (ITableSelection)intersectTable;
if (intersectTableSelection.SelectionSet.Count == 0)
{
AAState.WriteLine(" ERROR: No assests selected in " + intersectLayerName);
break;
}
if (intersectTableSelection.SelectionSet.Count > 1)
{
AAState.WriteLine(" ERROR: To many assests are selected in " + intersectLayerName);
break;
}
intersectTableSelection.SelectionSet.Search(null, true, out cCurs);
}
else
{
AAState.WriteLine(" ERROR: Asset Layer(" + intersectLayerName + ") not found");
break;
}
IRow row;
while ((row = cCurs.NextRow()) != null)
{
string val = row.get_Value(intersectFieldPos).ToString();
if (inObject.Fields.get_Field(fieldNum).Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(fieldNum, val);
else
{
if (Globals.IsNumeric(val))
{
inObject.set_Value(fieldNum, row.get_Value(intersectFieldPos));
}
else
{
AAState.WriteLine(" ERROR: Field is a number and ID from Asset is not - ID:" + val);
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: LINK_TABLE_ASSET" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: LINK_TABLE_ASSET");
}
break;
case "GET_ADDRESS_USING_GEOCODER":
{
try
{
AAState.WriteLine(" Trying GET_ADDRESS_USING_GEOCODER");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 2)
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
}
else
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
AAState.WriteLine(" Trying to get address locator");
IReverseGeocoding reverseGeocoding = Globals.OpenLocator(args[0], args[1]);
if (reverseGeocoding == null)
{
AAState.WriteLine(" ERROR: Reverse Address not locator found");
break;
}
AAState.WriteLine(" Reverse Address locator found");
AAState.WriteLine(" Retrieving Location to reverse geocode");
IPoint revGCLoc = Globals.GetGeomCenter(inFeature);
AAState.WriteLine(" Location retrieved");
// Create a Point at which to find the address.
IAddressGeocoding addressGeocoding = (IAddressGeocoding)reverseGeocoding;
IFields matchFields = addressGeocoding.MatchFields;
int shpFld = matchFields.FindField("Shape");
IField shapeField = matchFields.get_Field(shpFld);
AAState.WriteLine(" Setting distance");
// Set the search tolerance for reverse geocoding.
IReverseGeocodingProperties reverseGeocodingProperties =
(IReverseGeocodingProperties)reverseGeocoding;
reverseGeocodingProperties.SearchDistance = 100;
reverseGeocodingProperties.SearchDistanceUnits = esriUnits.esriFeet;
// Find the address nearest the Point.
IPropertySet addressProperties = reverseGeocoding.ReverseGeocode(revGCLoc, false);
// Print the address properties.
IAddressInputs addressInputs = (IAddressInputs)reverseGeocoding;
IFields addressFields = addressInputs.AddressFields;
object key, value;
addressProperties.GetAllProperties(out key, out value);
//object[] keyArray = key as object[];
//object[] valueArray = value as object[];
//for (int i = 0; i < keyArray.Length; i++)
//{
// if (keyArray[i].ToString() == "Shape")
// {
// IPoint addressPoint = valueArray[i] as IPoint;
// Console.WriteLine(keyArray[i] + " = " + addressPoint.X + ", " +
// addressPoint.Y);
// }
// else
// Console.WriteLine(keyArray[i] + " = " + valueArray[i]);
//}
for (int i = 0; i < addressFields.FieldCount; i++)
{
IField addressField = addressFields.get_Field(i);
string tempVal = addressProperties.GetProperty(addressField.Name).ToString();
inFeature.set_Value(fieldNum, tempVal);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GET_ADDRESS_USING_GEOCODER" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GET_ADDRESS_USING_GEOCODER");
}
break;
}
break;
case "GET_ADDRESS_USING_ARCGIS_SERVICE": //ARGS: url
try
{
AAState.WriteLine(" Trying GET_ADDRESS_USING_ARCGIS_SERVICE");
if (fieldObj.Type == esriFieldType.esriFieldTypeString)
{
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
IPoint revGCLoc = Globals.GetGeomCenter(inFeature);
if (revGCLoc != null)
{
//Test for user specified URL
if (Globals.IsUrl(valData))
{
locatorURL = valData;
/////locatorURL.TrimEnd(char[] );
if (!(locatorURL.EndsWith(reverseGeocode)))
locatorURL += reverseGeocode;
}
//If no valid user speficied URL, test for keywords for North America or European Union locators
else if (valData == "ESRI_Geocode_NA" || valData == "ESRI_Geocode_EU")
locatorURL = _agsOnlineLocators + valData + reverseGeocode;
else if (valData == "TA_Streets_US " || valData == "TA_Address_NA" || valData == "TA_Address_EU")
locatorURL = _agsOnlineLocators + valData + reverseGeocode;
//Default to AGS Online USA geocode service
else if (_agsOnlineLocators.Substring(_agsOnlineLocators.LastIndexOf('/', _agsOnlineLocators.Length - 2)).Contains("Locator"))
locatorURL = _agsOnlineLocators + "TA_Address_NA" + reverseGeocode;
else
locatorURL = _agsOnlineLocators + reverseGeocode;
//Copy point from this current feature
_copyPoint = revGCLoc;//inFeature.ShapeCopy as IPoint;
//Project point to WGS84
_copyPoint.Project(AAState.srWGS84);
//Include location parameters in URL
string results = Globals.FormatLocationRequest(locatorURL, _copyPoint.X, _copyPoint.Y, 100);
//Send and receieve the request
WebRequest req = WebRequest.Create(results);
WebResponse res = req.GetResponse();
//Convert response from JSON to XML
XmlDocument doc = new XmlDocument();
using (Stream s = res.GetResponseStream())
{
XmlDictionaryReader xr = JsonReaderWriterFactory.CreateJsonReader(s, XmlDictionaryReaderQuotas.Max);
doc.Load(xr);
xr.Close();
s.Close();
//Store Address element from Address Results in the specified field
//if (mode == "ON_CREATE")
//{
// inFeature.set_Value(fieldNum, doc.DocumentElement.FirstChild.FirstChild.InnerText.Replace(" ", " "));
//}
//else//on change
//{
// if (inFeature.Fields.get_Field(fieldNum).DefaultValue == inFeature.get_Value(fieldNum))
// //if (inFeature.get_Value(fieldNum).ToString() != "")
// {
// inFeature.set_Value(fieldNum, doc.DocumentElement.FirstChild.FirstChild.InnerText.Replace(" ", " "));
// }
//}
inFeature.set_Value(fieldNum, doc.DocumentElement.FirstChild.FirstChild.InnerText.Replace(" ", " "));
}
}
else
{
AAState.WriteLine(" Could not get location to Reverse Geocode");
}
}
}
}
catch
{
AAState.WriteLine(" ERROR: GET_ADDRESS_USING_ARCGIS_SERVICE");
}
finally
{
AAState.WriteLine(" Finished: GET_ADDRESS_USING_ARCGIS_SERVICE");
}
break;
case "TIMESTAMP":
try
{
AAState.WriteLine(" Trying: TIMESTAMP");
if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
inObject.set_Value(fieldNum, DateTime.Now);
else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(fieldNum, DateTime.Now.ToString());
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TIMESTAMP " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TIMESTAMP");
}
break;
case "LAST_VALUE":
try
{
AAState.WriteLine(" Trying: LAST_VALUE");
if (mode == "ON_CREATE")
{
lastValue = AAState.lastValueProperties.GetProperty(fieldName);
if (lastValue != null)
{
inObject.set_Value(fieldNum, lastValue);
AAState.WriteLine(" " + fieldName + ": " + lastValue);
}
}
else if (mode == "ON_CHANGE" && inObject.get_Value(fieldNum) == null)
{
lastValue = AAState.lastValueProperties.GetProperty(fieldName);
if (lastValue != null)
{
inObject.set_Value(fieldNum, lastValue);
AAState.WriteLine(" " + fieldName + ": " + lastValue);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: LAST_VALUE " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: LAST_VALUE");
}
break;
case "X_COORDINATE":
try
{
AAState.WriteLine(" Trying: X_COORDINATE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.Shape as IPoint;
inFeature.set_Value(fieldNum, _copyPoint.X);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
if (valData == "")
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolyline).X);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(fieldNum, _copyPolyline.FromPoint.X);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(fieldNum, _copyPolyline.ToPoint.X);
}
else
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolyline).X);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolygon).X);
}
else
{
AAState.WriteLine(" ERROR: Unsupported Geometry");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: X_COORDINATE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: X_COORDINATE");
}
break;
case "Y_COORDINATE":
try
{
AAState.WriteLine(" Trying: Y_COORDINATE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.Shape as IPoint;
inFeature.set_Value(fieldNum, _copyPoint.Y);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
if (valData == "")
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolyline).Y);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(fieldNum, _copyPolyline.FromPoint.Y);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(fieldNum, _copyPolyline.ToPoint.Y);
}
else
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolyline).Y);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolygon).Y);
}
else
{
AAState.WriteLine(" ERROR: Unsupported Geometry");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Y_COORDINATE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: Y_COORDINATE");
}
break;
case "LATITUDE":
try
{
AAState.WriteLine(" Trying: LATITUDE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.ShapeCopy as IPoint;
_copyPoint.Project(AAState._sr1);
inFeature.set_Value(fieldNum, _copyPoint.Y);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.ShapeCopy as IPolyline;
_copyPolyline.Project(AAState._sr1);
if (valData == "")
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolyline).X);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(fieldNum, _copyPolyline.FromPoint.X);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(fieldNum, _copyPolyline.ToPoint.X);
}
else
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolyline).X);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
_copyPolygon.Project(AAState._sr1);
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolygon).X);
}
else
{
AAState.WriteLine(" ERROR: Unsupported Geometry");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" Error: LATITUDE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: LATITUDE");
}
break;
case "LONGITUDE":
try
{
AAState.WriteLine(" Trying: LONGITUDE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.ShapeCopy as IPoint;
_copyPoint.Project(AAState._sr1);
inFeature.set_Value(fieldNum, _copyPoint.Y);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
_copyPolyline.Project(AAState._sr1);
if (valData == "")
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolyline).Y);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(fieldNum, _copyPolyline.FromPoint.Y);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(fieldNum, _copyPolyline.ToPoint.Y);
}
else
{
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolyline).Y);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
_copyPolygon.Project(AAState._sr1);
inFeature.set_Value(fieldNum, Globals.GetGeomCenter(_copyPolygon).Y);
}
else
{
AAState.WriteLine(" ERROR: Unsupported Geometry");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: LONGITUDE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: LONGITUDE");
}
break;
case "FIELD":
try
{
AAState.WriteLine(" Trying: Field");
// verify that field to copy exists
fieldCopy = inObject.Fields.FindField(valData as string);
if (fieldCopy > -1)
{
if (mode == "ON_CREATE")
{
inObject.set_Value(fieldNum, inObject.get_Value(fieldCopy));
}
if (mode == "ON_CHANGE")
{
//copy value only if current field is empty
if (inObject.get_Value(fieldNum).ToString() == "")
inObject.set_Value(fieldNum, inObject.get_Value(fieldCopy));
}
}
else
{
AAState.WriteLine(" " + valData + " is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Field: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: Field");
}
break;
//CURRENT_USER
//Value Data options:
//U - windows username only
//W or (blank) - full username including domain i.e. domain\username
//D - database user if available and not dbo
case "CURRENT_USER":
try
{
AAState.WriteLine(" Trying: CURRENT_USER");
lastEditorName = AAState._currentUserInfo.GetCurrentUser(valData, fieldObj.Length);
if (!String.IsNullOrEmpty(lastEditorName))
{
inObject.set_Value(fieldNum, lastEditorName);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: CURRENT_USER: "******" Finished: CURRENT_USER");
}
break;
case "JUNCTION_ROTATION":
try
{
AAState.WriteLine(" Trying: JUNCTION_ROTATION");
if ((inFeature != null))
{
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolGeographic;
args = null;
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args[0].Length == 0)
{
if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolArithmetic;
}
if (args[0].Length == 1)
{
if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolArithmetic;
if (Globals.IsNumeric(args[1].ToString()))
AAState.rCalc.SpinAngle = Convert.ToDouble(args[1]);
}
}
AAState.WriteLine(" " + AAState.rCalc.RotationType.ToString() + " is being used");
rotationAngle = AAState.rCalc.GetRotationUsingConnectedEdges(inFeature);
if (rotationAngle == null)
{
AAState.WriteLine(" Rotation Angle not found or errored out");
continue;
}
//Accept optional second argument to provide extra rotation
//if ((args != null) && (args.Length > 1) && (Globals.IsInteger(args[1])))
// rotationAngle += System.Convert.ToInt32(args[1]);
if (rotationAngle != -1)
inObject.set_Value(fieldNum, rotationAngle);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: JUNCTION_ROTATION \r\n" + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: JUNCTION_ROTATION");
}
break;
//For Release: 1.2
//New Dynamic Value Method: Length - stores calculated length of line feature
case "LENGTH":
try
{
AAState.WriteLine(" Trying: LENGTH");
if (inFeature != null)
{
curve = (ICurve)inFeature.Shape;
if (curve != null)
{
inObject.set_Value(fieldNum, curve.Length);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: LENGTH: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: LENGTH");
}
break;
//Release: 1.2
//New Dynamic Value Method: SET_MEASURES - stores calculated M values (from 0 to length of line) for line feature
//Value Data options:
//P = Percent - Ms will be zero to 100
//default - Ms will be zero to length of line
case "SET_MEASURES":
try
{
AAState.WriteLine(" Trying: SET_MEASURES");
if (inFeature != null)
{
curve = inFeature.Shape as ICurve;
mseg = inFeature.Shape as IMSegmentation;
if (curve != null && mseg != null)
if (valData != null && valData != "" && valData.Substring(0, 1).ToUpper() == "P")
mseg.SetAndInterpolateMsBetween(0, 100);
else
mseg.SetAndInterpolateMsBetween(0, curve.Length);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: SET_MEASURES: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: SET_MEASURES");
}
break;
//case "EDGE_INTERSECT_SECOND":
// try
// {
// if (inFeature != null)
// {
// netFeat = inFeature as INetworkFeature;
// if (netFeat != null)
// {
// if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
// {
// iJuncFeat = (IJunctionFeature)netFeat;
// // IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
// ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
// if (iSJunc == null)
// break;
// if (iSJunc.EdgeFeatureCount <= 1)
// break;
// edgeFeat = iSJunc.get_EdgeFeature(1);
// // verify that field (in junction) to copy exists
// IRow pRow = edgeFeat as IRow;
// juncField = pRow.Fields.FindField(valData as string);
// if (juncField > -1)
// {
// inObject.set_Value(fieldNum, pRow.get_Value(juncField));
// }
// }
// }
// }
// }
// catch
// {
// }
// break;
//case "EDGE_INTERSECT_FIRST":
// try
// {
// if (inFeature != null)
// {
// netFeat = inFeature as INetworkFeature;
// if (netFeat != null)
// {
// if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
// {
// iJuncFeat = (IJunctionFeature)netFeat;
// // IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
// ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
// if (iSJunc == null)
// break;
// if (iSJunc.EdgeFeatureCount <= 0)
// break;
// edgeFeat = iSJunc.get_EdgeFeature(0);
// IRow pRow = edgeFeat as IRow;
// juncField = pRow.Fields.FindField(valData as string);
// if (juncField > -1)
// {
// inObject.set_Value(fieldNum, pRow.get_Value(juncField));
// }
// }
// }
// }
// }
// catch
// {
// }
// break;
//Release: 2.0
//New Dynamic Value Method: TO_EDGE_FIELD transfers a field value from a connected egde feature to a junction feature
//Takes value from the frist edge whose "TO" point connects with this junction
case "TO_EDGE_FIELD":
try
{
AAState.WriteLine(" Trying: TO_EDGE_FIELD");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
edgeFeat = iSJunc.get_EdgeFeature(i);
try
{
juncFeat = (IFeature)edgeFeat.FromJunctionFeature;
if (juncFeat.Shape.Equals(inFeature.Shape))
{
IRow pRow = edgeFeat as IRow;
// verify that field (in junction) to copy exists
juncField = pRow.Fields.FindField(valData as string);
if (juncField > -1)
{
inObject.set_Value(fieldNum, pRow.get_Value(juncField));
}
else
{
AAState.WriteLine(" " + valData + " field not found in edge");
}
break;
}
}
catch
{
}
}
}
else
{
AAState.WriteLine(" No Connected Edges Found");
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_EDGE_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_EDGE_FIELD");
}
break;
//Release: 2.0
//New Dynamic Value Method: FROM_EDGE_FIELD transfers a field value from a connected egde feature to a junction feature
//Takes value from the frist edge whose "FROM" point connects with this junction
case "FROM_EDGE_FIELD":
try
{
AAState.WriteLine(" Trying: FROM_EDGE_FIELD");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
edgeFeat = iSJunc.get_EdgeFeature(i);
try
{
juncFeat = (IFeature)edgeFeat.ToJunctionFeature;
if (juncFeat.Shape.Equals(inFeature.Shape))
{
IRow pRow = edgeFeat as IRow;
// verify that field (in junction) to copy exists
juncField = pRow.Fields.FindField(valData as string);
if (juncField > -1)
{
inObject.set_Value(fieldNum, pRow.get_Value(juncField));
}
else
{
AAState.WriteLine(" " + valData + " field not found");
}
break;
}
}
catch
{
AAState.WriteLine(" error ");
}
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: FROM_EDGE_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: FROM_EDGE_FIELD");
}
break;
case "FROM_JUNCTION_FIELD":
try
{
AAState.WriteLine(" Trying: FROM_JUNCTION_FIELD");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
edgeFeat = (IEdgeFeature)netFeat;
juncFeat = (IFeature)edgeFeat.FromJunctionFeature;
// verify that field (in junction) to copy exists
juncField = juncFeat.Fields.FindField(valData as string);
if (juncField > -1)
{
inObject.set_Value(fieldNum, juncFeat.get_Value(juncField));
}
else
AAState.WriteLine(" " + valData + " field not found");
}
else
AAState.WriteLine(" not an edge feature");
}
else
AAState.WriteLine(" Not a network feature");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: FROM_JUNCTION_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: FROM_JUNCTION_FIELD");
}
break;
//Release: 1.2
//New Dynamic Value Method: TO_JUNCTION_FIELD transfers a field value from a junction connected at terminal end of a line feature
case "TO_JUNCTION_FIELD":
try
{
AAState.WriteLine(" Trying: TO_JUNCTION_FIELD");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
edgeFeat = (IEdgeFeature)netFeat;
juncFeat = (IFeature)edgeFeat.ToJunctionFeature;
// verify that field (in junction) to copy exists
juncField = juncFeat.Fields.FindField(valData as string);
if (juncField > -1)
{
inObject.set_Value(fieldNum, juncFeat.get_Value(juncField));
}
else
{
AAState.WriteLine(" Trying: TO_JUNCTION_FIELD");
}
}
}
else
{
AAState.WriteLine(" not an edge feature");
}
}
else
{
AAState.WriteLine(" not an geometric network feature");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_JUNCTION_FIELD:" + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_JUNCTION_FIELD");
}
break;
//Release: 1.2
//New Dynamic Value Method: GENERATE_ID - uses value in specificed table and increments it as specified
case "GENERATE_ID":
try
{
AAState.WriteLine(" Trying: GENERATE_ID");
if (AAState._gentab != null)
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
formatString = "";
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
sequenceColumnName = args[0].ToString(); break;
case 2: // sequenceColumnName|sequenceFixedWidth
sequenceColumnName = args[0].ToString();
sequenceFixedWidth = args[1].ToString();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
sequenceColumnName = args[0].ToString();
sequenceFixedWidth = args[1].ToString();
formatString = args[2].ToString();
break;
default: break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
if (sequencePadding > 25)
{
AAState.WriteLine(" WARNING: you are trying to pad your id with a more than 25 - 0's");
AAState.WriteLine(" WARNING: " + sequencePadding + " 0's is what you have");
}
else if (sequencePadding > 50)
{
MessageBox.Show("You are trying to add 50 places to your ID, this is not supported, please fix your dynamic value table");
}
//Check for sequence column in generate id table
sequenceColumnNum = AAState._gentab.FindField(sequenceColumnName);
if (AAState._gentab.FindField(sequenceColumnName) >= 0)
{
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = AAState._gentab.Update(null, false).NextRow();
if (row == null)
{
break;
}
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
sequenceValue += 1;
// _editEvents.OnChangeFeature -= OnChangeFeature;
// _editEvents.OnCreateFeature -= OnCreateFeature;
row.set_Value(sequenceColumnNum, sequenceValue);
AAState.WriteLine(" " + row.Fields.get_Field(sequenceColumnNum).AliasName + " changed to " + sequenceValue);
row.Store();
// _editEvents.OnChangeFeature += OnChangeFeature;
// _editEvents.OnCreateFeature += OnCreateFeature;
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
AAState.WriteLine(" ERROR: GENERATE_ID: Sequence Not Found");
}
else
{
if (inObject.Fields.get_Field(fieldNum).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || formatString.ToLower().IndexOf("[seq]") == -1)
{
string setVal = (sequenceValue.ToString("D" + sequencePadding) + sequencePostfix).ToString();
if (inObject.Fields.get_Field(fieldNum).Length < setVal.Length && inObject.Fields.get_Field(fieldNum).Length != 0)
{
AAState.WriteLine(" ERROR: " + sequenceValue + " is to long for field " + row.Fields.get_Field(sequenceColumnNum).AliasName);
}
else
{
inObject.set_Value(fieldNum, sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
AAState.WriteLine(" " + inObject.Fields.get_Field(fieldNum).AliasName + " set to " + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
}
}
else
{
int locIdx = formatString.ToUpper().IndexOf("[SEQ]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 5);
formatString = formatString.Insert(locIdx, sequenceValue.ToString("D" + sequencePadding));
}
//formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
if (inObject.Fields.get_Field(fieldNum).Length < formatString.Length && inObject.Fields.get_Field(fieldNum).Length != 0)
{
AAState.WriteLine(" ERROR: " + formatString + " is to long for field " + row.Fields.get_Field(sequenceColumnNum).AliasName);
}
else
{
inObject.set_Value(fieldNum, formatString);
AAState.WriteLine(" " + inObject.Fields.get_Field(fieldNum).AliasName + " set to " + formatString);
}
}
else
{
inObject.set_Value(fieldNum, sequenceValue);
AAState.WriteLine(" " + sequenceColumnNum + " changed to " + sequenceValue);
}
}
}
else
{
AAState.WriteLine(" Sequence Field not found");
}
}
else
{
AAState.WriteLine(" ERROR: GENERATE_ID table is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GENERATE_ID: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GENERATE_ID");
}
break;
case "GENERATE_ID_BY_INTERSECT":
try
{
AAState.WriteLine(" Trying: GENERATE_ID_BY_INTERSECT");
if (AAState._gentab != null && inFeature != null && !(inFeature.Shape.IsEmpty))
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
//genIdAreaFieldName = "";
intersectLayerName = "";
intersectLayerFieldName = "";
formatString = "";
intersectFieldPos = -1;
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
if (args.GetLength(0) < 3)
{
AAState.WriteLine(" ERROR: Improper value method");
break;
}
switch (args.GetLength(0))
{
case 3: //columnName
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
// genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
break;
case 4: // columnName|sequenceFixedWidth
//sequenceFixedWidth formats the sequence with leading zeros to create specified width
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
sequenceFixedWidth = Convert.ToString(0);
formatString = args[3].ToString();
break;
case 5: // columnName|sequenceFixedWidth|formatString
//formatString must contain [seq] and [id] and may contain [area] plus any desired text
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
sequenceFixedWidth = args[3].ToString();
formatString = args[4].ToString();
break;
default: break;
}
//Find Area Layer
// FindLayerByName(areaLayerName, out areaLayer);
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName);
if (intersectLayer == null)
{
AAState.WriteLine(" ERROR: Intersecting feature Layer(" + intersectLayerName + ") not found");
break;
}
//Find Area Field
intersectFieldPos = intersectLayer.FeatureClass.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(" ERROR: Intersecting feature Layer Field(" + intersectLayerFieldName + ") not found");
break;
}
//Find GenID Area Field
//genIdAreaFieldPos = areaLayer.FeatureClass.FindField(genIdAreaFieldName);
//if (genIdAreaFieldPos < 0) break;
//Perform spatial search
IGeometry pSearchGeo = (IGeometry)inFeature.ShapeCopy;
pSearchGeo.SpatialReference = (inFeature.Class as IGeoDataset).SpatialReference;
pSearchGeo.Project((intersectLayer as IGeoDataset).SpatialReference);
sFilter = new SpatialFilterClass();
sFilter.Geometry = pSearchGeo;
sFilter.GeometryField = intersectLayer.FeatureClass.ShapeFieldName;
sFilter.SubFields = intersectLayerFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
sourceFeature = fCursor.NextFeature();
if (sourceFeature != null)
intersectValue = sourceFeature.get_Value(intersectFieldPos).ToString();
else
{
AAState.WriteLine(" ERROR: Intersecting feature not found");
break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
if (sequencePadding > 25)
{
AAState.WriteLine(" WARNING: you are trying to pad your id with a more than 25 - 0's");
AAState.WriteLine(" WARNING: " + sequencePadding + " 0's is what you have");
}
sequenceColumnName = sequenceColumnName + intersectValue;
AAState.WriteLine(" Looking for a field called " + sequenceColumnName + " in the generate ID table");
sequenceColumnNum = AAState._gentab.FindField(sequenceColumnName);
if (sequenceColumnNum > -1)
{
AAState.WriteLine(" Field Found");
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = AAState._gentab.Update(qFilter, false).NextRow();
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
sequenceValue += 1;
row.set_Value(sequenceColumnNum, sequenceValue);
row.Store();
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
AAState.WriteLine(" ERROR: Sequence number not found");
}
else
{
if (inObject.Fields.get_Field(fieldNum).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || (formatString.ToUpper().IndexOf("[SEQ]") == -1 && formatString.ToUpper().IndexOf("[ID]") == -1))
inObject.set_Value(fieldNum, intersectValue + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
else
{
int locIdx = formatString.ToUpper().IndexOf("[ID]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 4);
formatString = formatString.Insert(locIdx, intersectValue);
}
// formatString = formatString.Replace("[id]", intersectValue);
// formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
locIdx = formatString.ToUpper().IndexOf("[SEQ]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 5);
formatString = formatString.Insert(locIdx, sequenceValue.ToString());
}
//
inObject.set_Value(fieldNum, formatString);
}
else
inObject.set_Value(fieldNum, sequenceValue);
}
}
else
{
AAState.WriteLine(" ERROR: Field NOT Found");
}
}
else
{
AAState.WriteLine(" ERROR: GENERATE_ID table is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GENERATE_ID_BY_INTERSECT: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GENERATE_ID_BY_INTERSECT");
}
break;
//Modified for Release 1.2 (No longer uses ICalculator)
//Requires valid VBScript expression
//Can include string, numeric, and date fields by name in square brackets []
//Example: DateDiff("yyyy",[INSTALLDATE],Now())
case "GENERATE_ID_BY_AREA":
try
{
AAState.WriteLine(" Trying: GENERATE_ID_BY_AREA");
if (AAState._gentab != null && inFeature != null && !(inFeature.Shape.IsEmpty))
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
genIdAreaFieldName = "";
areaLayerName = "";
areaLayerFieldName = "";
formatString = "";
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
if (args.GetLength(0) < 3)
{
AAState.WriteLine(" ERROR: Improper Value Method");
break;
}
switch (args.GetLength(0))
{
case 4: //columnName
areaLayerName = args[0].ToString();
areaLayerFieldName = args[1].ToString();
genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[3].ToString();
break;
case 5: // columnName|sequenceFixedWidth
//sequenceFixedWidth formats the sequence with leading zeros to create specified width
areaLayerName = args[0].ToString();
areaLayerFieldName = args[1].ToString();
genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[3].ToString();
sequenceFixedWidth = args[4].ToString();
break;
case 6: // columnName|sequenceFixedWidth|formatString
//formatString must contain [seq] and may contain [area] plus any desired text
areaLayerName = args[0].ToString();
areaLayerFieldName = args[1].ToString();
genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[3].ToString();
sequenceFixedWidth = args[4].ToString();
formatString = args[5].ToString();
break;
default: break;
}
//Find Area Layer
// FindLayerByName(areaLayerName, out areaLayer);
areaLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, areaLayerName);
if (areaLayer == null)
{
AAState.WriteLine(" ERROR: Area Layer not found: " + areaLayerName);
break;
}
//Find Area Field
areaFieldPos = areaLayer.FeatureClass.FindField(areaLayerFieldName);
if (areaFieldPos < 0)
{
AAState.WriteLine(" ERROR: Area Layer field not found: " + areaLayerFieldName);
break;
}
//Find GenID Area Field
//genIdAreaFieldPos = areaLayer.FeatureClass.FindField(genIdAreaFieldName);
//if (genIdAreaFieldPos < 0) break;
//Perform spatial search
sFilter = new SpatialFilterClass();
sFilter.Geometry = (IGeometry)inFeature.ShapeCopy;
sFilter.GeometryField = areaLayer.FeatureClass.ShapeFieldName;
sFilter.SubFields = areaLayerFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
fCursor = areaLayer.FeatureClass.Search(sFilter, true);
sourceFeature = fCursor.NextFeature();
if (sourceFeature != null)
areaValue = sourceFeature.get_Value(areaFieldPos).ToString();
else
break;
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
sequenceColumnNum = AAState._gentab.FindField(sequenceColumnName);
if (sequenceColumnNum > -1)
{
qFilter = new QueryFilterClass();
qFilter.SubFields = areaLayerFieldName + "," + sequenceColumnName;
ISQLSyntax sqlSyntax = (ISQLSyntax)AAState._editor.EditWorkspace;
char[] charBuf = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix).ToCharArray();
string strSC = new string(charBuf);
switch (strSC)
{
case "":
qFilter.WhereClause = genIdAreaFieldName + " = '" + areaValue + "'";
break;
case "[":
qFilter.WhereClause = "[" + genIdAreaFieldName + "]" + " = '" + areaValue + "'";
break;
default:
qFilter.WhereClause = "\"" + genIdAreaFieldName + "\" = '" + areaValue + "'";
break;
}
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = AAState._gentab.Update(qFilter, false).NextRow();
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
sequenceValue += 1;
sequenceValue += 1;
row.set_Value(sequenceColumnNum, sequenceValue);
row.Store();
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
//TODO raise error
}
else
{
if (inObject.Fields.get_Field(fieldNum).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || formatString.IndexOf("[seq]") == -1)
inObject.set_Value(fieldNum, areaValue + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
else
{
formatString = formatString.Replace("[area]", areaValue);
formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
inObject.set_Value(fieldNum, formatString);
}
else
inObject.set_Value(fieldNum, sequenceValue);
}
}
}
else
{
AAState.WriteLine(" ERROR: GENERATE_ID table is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GENERATE_ID_BY_AREA: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GENERATE_ID_BY_AREA");
}
break;
//Modified for Release 1.2 (No longer uses ICalculator)
//Requires valid VBScript expression
//Can include string, numeric, and date fields by name in square brackets []
//Example: DateDiff("yyyy",[INSTALLDATE],Now())
case "EXPRESSION":
try
{
AAState.WriteLine(" Trying: EXPRESSION");
if (inObject != null & valData != null)
{
newValue = valData;
for (int i = 0; i < inObject.Fields.FieldCount; i++)
{
testField = inObject.Fields.get_Field(i);
int indFld = newValue.ToUpper().IndexOf("[" + testField.Name.ToUpper() + "]");
while (indFld >= 0)
{
AAState.WriteLine(" replace field: " + testField.Name + " with a value");
int fldLen = testField.Name.Length;
string tmpStr1 = newValue.Substring(0, indFld + 1);
string tmpStr2 = newValue.Substring(indFld + fldLen + 1);
newValue = tmpStr1 + "_REPLACE_VAL_" + tmpStr2;
switch (testField.Type)
{
case esriFieldType.esriFieldTypeString:
if (inObject.get_Value(i) == null || inObject.get_Value(i).ToString() == "")
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(i) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", null);
}
else if (inObject.get_Value(i).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(i).ToString() + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(i).ToString() + "\"");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(i).ToString() + "\"");
}
}
// newValue = newValue.Replace("[" + testField.Name + "]", "\"" + inObject.get_Value(i).ToString() + "\"");
break;
case esriFieldType.esriFieldTypeDate:
if (inObject.get_Value(i) == null || inObject.get_Value(i).ToString() == "")
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(i) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "CDATE(" + null + ")");
}
else if (inObject.get_Value(i).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(i).ToString() + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "CDATE(\"" + inObject.get_Value(i).ToString() + "\")");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "CDATE(\"" + inObject.get_Value(i).ToString() + "\")");
}
}
// newValue = newValue.Replace("[" + testField.Name + "]", "CDATE(\"" + inObject.get_Value(i).ToString() + "\")");
break;
default:
if (inObject.get_Value(i) == null || inObject.get_Value(i).ToString() == "")
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(i) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", null);
}
else if (inObject.get_Value(i).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", null);// "\"" + inObject.get_Value(i).ToString() + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "" + inObject.get_Value(i).ToString() + "");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", inObject.get_Value(i).ToString());
}
}
// newValue = newValue.Replace("[" + testField.Name + "]", inObject.get_Value(i).ToString());
break;
}
indFld = newValue.ToUpper().IndexOf("[" + testField.Name.ToUpper() + "]");
}
}
//MessageBox.Show(newValue);
try
{
newValue = script.Eval(newValue).ToString();
if (inObject.get_Value(fieldNum).ToString() != newValue)
inObject.set_Value(fieldNum, newValue);
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: evaluating the expression for feature in " + inObject.Class.AliasName + " with OID of " + inObject.OID);
AAState.WriteLine(" " + ex.Message);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: EXPRESSION: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: EXPRESSION");
}
break;
// GUID values are calculated into text fields or into native GUID field types
// When using text field you have an optional argument (valdata) to specify the format
// N-none 32 chars, D-dash 36, B-braces 38, P-Parenthesis 38
case "GUID":
try
{
if (inObject != null)
{
if (inObject.Fields.get_Field(fieldNum).Type == esriFieldType.esriFieldTypeGUID)
inObject.set_Value(fieldNum, System.Guid.NewGuid().ToString("B"));
else if (inObject.Fields.get_Field(fieldNum).Type == esriFieldType.esriFieldTypeString &&
inObject.Fields.get_Field(fieldNum).Length >= 32)
{
valData = valData.Trim();
if (valData != "N" && valData != "D" && valData != "B" && valData != "P")
if (inObject.Fields.get_Field(fieldNum).Length >= 38)
valData = "B"; //Default to braces
else if (inObject.Fields.get_Field(fieldNum).Length < 36)
valData = "N";
else
valData = "D";
inObject.set_Value(fieldNum, System.Guid.NewGuid().ToString(valData));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: EXPRESSION: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: EXPRESSION");
}
break;
case "CREATE_LINKED_RECORD"://Feature Layer|Field To Copy|Field To Populate|Primary Key Field|Foreign Key Field
{
try
{
AAState.WriteLine(" Trying: CREATE_LINKED_RECORD");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 5)
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
}
else
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
if (inFeature == null)
{
AAState.WriteLine(" ERROR: The input features is null");
break;
}
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(" Getting Value Info");
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
string targetFieldName = args[2].ToString();
string sourceIDFieldName = args[3].ToString();
string targetIDFieldName = args[4].ToString();
AAState.WriteLine(" Checking values");
if (sourceFieldName != null)
{
AAState.WriteLine(" Checking Fields in Source Layer");
int fldValToCopyIdx = inObject.Fields.FindField(sourceFieldName);
int fldIDToCopyIdx = inObject.Fields.FindField(sourceIDFieldName);
if (fldValToCopyIdx > -1 && fldIDToCopyIdx > -1)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
// Get layer
AAState.WriteLine(" Checking for table to populate");
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName);
if (sourceLayer != null)
{
}
else
{
ITable pTable = Globals.FindTable(AAState._editor.Map, sourceLayerName);
if (pTable != null)
{
int fldValToPopIdx = pTable.Fields.FindField(targetFieldName);
int fldIDToPopIdx = pTable.Fields.FindField(targetIDFieldName);
if (fldValToPopIdx > -1 && fldIDToPopIdx > -1)
{
AAState.WriteLine(" Trying to create a row in the target table");
IRow pNewRow = pTable.CreateRow();
AAState.WriteLine(" Row Created");
AAState.WriteLine(" Trying to Copy ID");
try
{
pNewRow.set_Value(fldIDToPopIdx, inObject.get_Value(fldIDToCopyIdx));
}
catch
{
AAState.WriteLine(" ERROR: Could not Copy: " + inObject.get_Value(fldIDToCopyIdx) + " to field: " + targetIDFieldName);
}
AAState.WriteLine(" ID successfully copied");
AAState.WriteLine(" Trying to Copy Value");
try
{
pNewRow.set_Value(fldValToPopIdx, inObject.get_Value(fldValToCopyIdx));
}
catch
{
AAState.WriteLine(" ERROR: Could not Copy: " + inObject.get_Value(fldValToCopyIdx) + " to field: " + targetFieldName);
}
AAState.WriteLine(" Value successfully copied");
pNewRow.Store();
if (newFeatureList == null)
{
newFeatureList = new List<IObject>();
}
IObject featobj = pNewRow as IObject;
if (featobj != null)
{
newFeatureList.Add(featobj);
}
AAState.WriteLine(" Row successfully stored");
}
else
{
AAState.WriteLine(" ERROR: ID or Field to populate was not found");
}
}
else
{
AAState.WriteLine(" ERROR: Table to populate not found: " + sourceLayerName);
}
}
}
}
}
else
{
AAState.WriteLine(" ERROR: ID or Field to Copy was not found");
}
//if ((!found) && (inObject.Fields.get_Field(fieldNum).IsNullable))
//{
// inObject.set_Value(fieldNum, null);
//}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: CREATE_LINKED_RECORD" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: CREATE_LINKED_RECORD");
// fieldNum = -1;
}
break;
}
case "UPDATE_INTERSECTING_FEATURE"://Intersected Feature|FieldIntersectingFeatureToChange|FromFieldinModifiedFeature
{
try
{
AAState.WriteLine(" Trying: UPDATE_INTERSECTING_FEATURE");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 3)
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
}
else
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
if (inFeature == null)
{
AAState.WriteLine(" ERROR: The input features is null");
break;
}
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(" Getting Value Info");
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
string targetFieldName = args[2].ToString();
AAState.WriteLine(" Checking values");
if (sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
// Get layer
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName);
if (sourceLayer != null)
{
if (inObject.Class != sourceLayer.FeatureClass)
{
if (Globals.IsEditable(sourceLayer, AAState._editor))
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
sFilter = new SpatialFilterClass();
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
try
{
ISpatialReferenceResolution pSRResolution;
pSRResolution = ((sourceLayer.FeatureClass as IGeoDataset).SpatialReference) as ISpatialReferenceResolution;
// sFilter = new SpatialFilterClass();
double intTol = pSRResolution.get_XYResolution(false);
bool hasXY = ((sourceLayer.FeatureClass as IGeoDataset).SpatialReference).HasXYPrecision();
searchEnvelope = new EnvelopeClass();
searchEnvelope.XMin = 0 - intTol;
searchEnvelope.YMin = 0 - intTol;
searchEnvelope.XMax = 0 + intTol;
searchEnvelope.YMax = 0 + intTol;
searchEnvelope.CenterAt(inFeature.ShapeCopy as IPoint);
//searchEnvelope.SpatialReference = ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference;
searchEnvelope.SpatialReference = ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference;
searchEnvelope.SnapToSpatialReference();
searchEnvelope.Project(AAState._editor.Map.SpatialReference);
sFilter.Geometry = Globals.Env2Polygon(searchEnvelope);
}
catch
{
sFilter.Geometry = inFeature.ShapeCopy;
}
}
else
{
sFilter.Geometry = inFeature.ShapeCopy;
}
sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
fCursor = sourceLayer.FeatureClass.Search(sFilter, false);
sourceFeature = fCursor.NextFeature();
if (sourceFeature != null)
{
int fldIdx = inFeature.Fields.FindField(targetFieldName);
AAState.WriteLine(" " + targetFieldName + " at index " + fldIdx);
string test = targetFieldName;
if (fldIdx > -1)
{
test = inFeature.get_Value(fldIdx).ToString();
AAState.WriteLine(" Value Found " + test);
}
AAState.WriteLine(" Value used " + test);
try
{
if (sourceFeature.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeString)
{
sourceFeature.set_Value(sourceField, test);
sourceFeature.Store();
found = true;
break;
}
else
{
if (Globals.IsNumeric(test))
{
if (sourceFeature.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSmallInteger ||
sourceFeature.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeInteger)
{
sourceFeature.set_Value(sourceField, Convert.ToInt32(test));
sourceFeature.Store();
found = true;
break;
}
else if (sourceFeature.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeDouble ||
sourceFeature.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSingle)
{
sourceFeature.set_Value(sourceField, Convert.ToDouble(test));
sourceFeature.Store(); found = true;
break;
}
else
{
sourceFeature.set_Value(sourceField, test as object);
sourceFeature.Store();
found = true;
break;
}
}
else
{
sourceFeature.set_Value(sourceField, test as object);
sourceFeature.Store();
found = true;
break;
}
}
}
catch
{
AAState.WriteLine(" ERROR setting value");
}
finally
{
if (found)
{
// break;
}
}
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer is not editable: " + sourceLayerName);
}
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer not found: " + sourceLayerName);
}
}
}
//if ((!found) && (inObject.Fields.get_Field(fieldNum).IsNullable))
//{
// inObject.set_Value(fieldNum, null);
//}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: UPDATE_INTERSECTING_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: UPDATE_INTERSECTING_FEATURE");
// fieldNum = -1;
}
break;
}
case "MULTI_FIELD_INTERSECT":
try
{
AAState.WriteLine(" Trying: MULTI_FIELD_INTERSECT");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int popFldIdx = 0;
if (args.GetLength(0) > 2)
{
AAState.WriteLine(" Parsing Valueinfo");
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
string[] fieldsToPop = args[2].ToString().Split(',');
if (args.GetLength(0) == 4)
{
AAState.WriteLine(" Search distance specified");
if (Globals.IsDouble(args[3]))
{
searchDistance = Convert.ToDouble(args[3]);
}
else
{
searchDistance = 0.0;
}
}
else
{
searchDistance = 0.0;
}
if (sourceFieldName != null)
{
AAState.WriteLine(" Looping Through Layers");
for (int i = 0; i < sourceLayerNames.Length; i++)
{
if (fieldsToPop.Length == popFldIdx)
break;
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
// Get layer
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName);
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
sFilter = new SpatialFilterClass();
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
searchEnvelope = Globals.CalcSearchExtent(sourceLayer, inFeature, searchDistance);
sFilter.Geometry = searchEnvelope;
}
else
{
sFilter.Geometry = inFeature.ShapeCopy;
}
sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
if (fieldsToPop.Length == popFldIdx)
break;
string test = sourceFeature.get_Value(sourceField).ToString();
int tempFieldNum = inObject.Fields.FindField(fieldsToPop[popFldIdx]);
popFldIdx++;
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, sourceFeature.get_Value(sourceField));
}
sourceFeature = fCursor.NextFeature();
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Datasource is invalid: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer not found: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer string is empty");
}
}
}
else
{
AAState.WriteLine(" ERROR: Field name is invalid");
}
}
else
{
AAState.WriteLine(" ERROR: Invalid Value method definition");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: MULTI_FIELD_INTERSECT: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: MULTI_FIELD_INTERSECT");
}
break;
case "INTERSECT_STATS":
try
{
AAState.WriteLine(" Trying: INTERSECT_STATS");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int AverageCount = 0;
if (args.GetLength(0) > 2)
{
AAState.WriteLine(" Parsing Valueinfo");
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
string statType = args[2].ToString();
if (args.GetLength(0) == 4)
{
AAState.WriteLine(" Search distance specified");
if (Globals.IsDouble(args[3]))
searchDistance = Convert.ToDouble(args[3]);
else
searchDistance = 0.0;
}
else
{
searchDistance = 0.0;
}
double result = -999999.1;
if (sourceFieldName != null)
{
AAState.WriteLine(" Looping Through Layers");
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
// Get layer
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName);
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
sFilter = new SpatialFilterClass();
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
searchEnvelope = Globals.CalcSearchExtent(sourceLayer, inFeature, searchDistance);
sFilter.Geometry = searchEnvelope;
}
else
{
sFilter.Geometry = inFeature.ShapeCopy;
}
sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
string test = sourceFeature.get_Value(sourceField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
default:
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Non numeric value returned: " + test);
}
sourceFeature = fCursor.NextFeature();
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Datasource is invalid: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer not found: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer string is empty");
}
}
if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(fieldNum, result);
}
else
{
IField field = inObject.Fields.get_Field(fieldNum);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(fieldNum, null);
}
}
else
{
inObject.set_Value(fieldNum, newval);
}
}
}
else
{
AAState.WriteLine(" ERROR: Field name is invalid");
}
}
else
{
AAState.WriteLine(" ERROR: Invalid Value method definition");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECT_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECT_STATS");
}
break;
case "INTERSECTING_FEATURE":
try
{
AAState.WriteLine(" Trying: INTERSECTING_FEATURE");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
// Parse arguments
args = valData.Split('|');
if (args.GetLength(0) >= 2)
{
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
if (sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
// Get layer
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName);
if (sourceLayer != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
sFilter = new SpatialFilterClass();
sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
sFilter.set_OutputSpatialReference(sourceLayer.FeatureClass.ShapeFieldName, (sourceLayer.FeatureClass as IGeoDataset).SpatialReference);
//sFilter.set_OutputSpatialReference(sourceLayer.FeatureClass.ShapeFieldName, AAState._editor.Map.SpatialReference);
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
try
{
IGeometry pSourceGeo = inFeature.ShapeCopy as IPoint;
pSourceGeo.SpatialReference = ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference;
pSourceGeo.Project((sourceLayer.FeatureClass as IGeoDataset).SpatialReference);
//pSourceGeo.Project(AAState._editor.Map.SpatialReference);
bool hasXY;
hasXY = ((sourceLayer.FeatureClass as IGeoDataset).SpatialReference).HasXYPrecision();
//hasXY = (AAState._editor.Map.SpatialReference).HasXYPrecision();
double intTol = .001;
if (hasXY)
{
ISpatialReferenceResolution pSRResolution;
pSRResolution = ((sourceLayer.FeatureClass as IGeoDataset).SpatialReference) as ISpatialReferenceResolution;
//pSRResolution = (AAState._editor.Map.SpatialReference) as ISpatialReferenceResolution;
intTol = pSRResolution.get_XYResolution(false) * 2;
}
searchEnvelope = new EnvelopeClass();
searchEnvelope.XMin = 0 - intTol;
searchEnvelope.YMin = 0 - intTol;
searchEnvelope.XMax = 0 + intTol;
searchEnvelope.YMax = 0 + intTol;
searchEnvelope.CenterAt(pSourceGeo as IPoint);
searchEnvelope.SpatialReference = ((sourceLayer.FeatureClass as IGeoDataset).SpatialReference);
//searchEnvelope.SpatialReference = (AAState._editor.Map.SpatialReference);
//searchEnvelope.SpatialReference = ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference;
//searchEnvelope.SnapToSpatialReference();
//if (AAState._editor.Map.SpatialReference != ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference)
//{
// searchEnvelope.Project((sourceLayer.FeatureClass as IGeoDataset).SpatialReference);
//searchEnvelope.Project(AAState._editor.Map.SpatialReference);
//}
sFilter.Geometry = Globals.Env2Polygon(searchEnvelope);
//searchEnvelope.Expand(.1, .1, true);
//searchEnvelope.Expand(searchDistance, searchDistance, false);
}
catch
{
IGeometry pGeo = inFeature.ShapeCopy;
pGeo.SpatialReference = ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference;
pGeo.Project(AAState._editor.Map.SpatialReference);
sFilter.Geometry = pGeo;
}
}
else
{
IGeometry pGeo = inFeature.ShapeCopy;
pGeo.SpatialReference = ((inFeature.Class as IFeatureClass) as IGeoDataset).SpatialReference;
pGeo.Project(AAState._editor.Map.SpatialReference);
sFilter.Geometry = pGeo;
}
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
string test = sourceFeature.get_Value(sourceField).ToString();
inObject.set_Value(fieldNum, sourceFeature.get_Value(sourceField));
found = true;
sourceFeature = fCursor.NextFeature();
}
if (found == false && AAState._CheckEnvelope)
{
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
// sFilter.SpatialRelDescription = "T*T***T*T";
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
string test = sourceFeature.get_Value(sourceField).ToString();
inObject.set_Value(fieldNum, sourceFeature.get_Value(sourceField));
found = true;
sourceFeature = fCursor.NextFeature();
}
}
if (found)
{
break;
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer not found: " + sourceLayerName);
}
}
}
if (!found)
{
IField field = inObject.Fields.get_Field(fieldNum);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(fieldNum, null);
}
}
else
{
inObject.set_Value(fieldNum, newval);
}
}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_FEATURE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_FEATURE");
}
break;
case "INTERSECTING_RASTER":
try
{
AAState.WriteLine(" Trying: INTERSECTING_RASTER");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
formatString = "";
found = false;
// Parse arguments
args = valData.Split('|');
if (args.Length < 1) break;
switch (args.Length)
{
case 1:
sourceLayerNames = args[0].ToString().Split(',');
break;
case 2:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
break;
default: break;
}
// Get layer
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
IPoint pLoc = Globals.GetGeomCenter(inFeature);
if (pLoc != null)
{
string cellVal = GetCellValue(sourceLayerName, pLoc, AAState._editor.Map);// Globals.GetCellValue(sourceLayerName, pLoc, _editor.Map);
AAState.WriteLine(" ERROR/WARING: No cell value or raster was found: " + sourceLayerName);
if (cellVal != null && cellVal != "" && cellVal != "No Raster")
{
if (formatString == null || formatString == "" || (inObject.Fields.get_Field(fieldNum).Type != esriFieldType.esriFieldTypeString))
{
inObject.set_Value(fieldNum, cellVal);
found = true;
break;
}
else
{
// formatString = formatString.Replace("[value]",cellVal);
formatString = formatString + cellVal;
inObject.set_Value(fieldNum, formatString);
found = true;
break;
}
}
}
}
if (!(found) && inObject.Fields.get_Field(fieldNum).IsNullable)
inObject.set_Value(fieldNum, null);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_RASTER: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_RASTER");
}
break;
case "INTERSECTING_LAYER_DETAILS":
try
{
AAState.WriteLine(" Trying: INTERSECTING_LAYER_DETAILS");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
formatString = "";
found = false;
// Parse arguments
args = valData.Split('|');
if (args.Length < 1) break;
switch (args.Length)
{
case 1:
sourceLayerNames = args[0].ToString().Split(',');
formatString = "P";
break;
case 2:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
break;
default: break;
}
// Get layer
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
//AAState.WriteLine(" Getting Features Centeroid");
//IPoint pLoc = Globals.GetGeomCenter(inFeature);
IGeometry pGeo = inFeature.ShapeCopy;
if (pGeo != null)
{
// AAState.WriteLine(" Centroid Found");
AAState.WriteLine(" Getting list of " + sourceLayerName + " Layers");
IEnumLayer pEnum = Globals.GetLayers(AAState._editor.Map, sourceLayerName);
if (pEnum != null)
{
AAState.WriteLine(" List retrieved of " + sourceLayerName + " Layers");
AAState.WriteLine(" Starting Loop");
ILayer pLay = pEnum.Next();
ISpatialFilter pSpatFilt;
while (pLay != null)
{
if (found)
{
AAState.WriteLine(" Exiting Layer Loop");
break;
}
AAState.WriteLine(" Checking " + pLay.Name);
if (pLay is IRasterLayer)
{
IRasterLayer pRasLay = pLay as IRasterLayer;
AAState.WriteLine(" Trying " + pRasLay.Name);
IEnvelope pEnv = pRasLay.AreaOfInterest;
// ITopologicalOperator pTopo = pEnv as ITopologicalOperator;
IRelationalOperator pRel = pEnv as IRelationalOperator;
IRelationalOperator2 pRel2 = pEnv as IRelationalOperator2;
if (pRel.Crosses(pGeo) || pRel.Touches(pGeo) || pRel.Overlaps(pGeo) || pRel2.ContainsEx(pGeo, esriSpatialRelationExEnum.esriSpatialRelationExClementini))
{
AAState.WriteLine(" Geometry does intersect " + pRasLay.Name);
switch (formatString)
{
case "P":
// IDataset pDS = pFLay.FeatureClass as IDataset;
inObject.set_Value(fieldNum, Globals.GetPathForALayer(pLay));
pRasLay = null;
pEnv = null;
pRel = null;
pRel2 = null;
found = true;
break;
case "N":
inObject.set_Value(fieldNum, pLay.Name);
pRasLay = null;
pEnv = null;
pRel = null;
pRel2 = null;
found = true;
break;
default:
inObject.set_Value(fieldNum, Globals.GetPathForALayer(pLay));
pRasLay = null;
pEnv = null;
pRel = null;
pRel2 = null;
found = true;
break;
}
}
}
else if (pLay is IFeatureLayer)
{
IFeatureLayer pFLay = pLay as IFeatureLayer;
if (pFLay.FeatureClass == inObject.Class)
{
}
else
{
AAState.WriteLine(" Trying " + pFLay.Name);
pSpatFilt = new SpatialFilterClass();
pSpatFilt.GeometryField = pFLay.FeatureClass.ShapeFieldName;
pSpatFilt.Geometry = pGeo as IGeometry;
pSpatFilt.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
if (pFLay.FeatureClass.FeatureCount(pSpatFilt) > 0)
{
AAState.WriteLine(" Geometry does intersect " + pFLay.Name);
switch (formatString)
{
case "P":
// IDataset pDS = pFLay.FeatureClass as IDataset;
// AAState.WriteLine(" Exiting Layer Loop");
inObject.set_Value(fieldNum, Globals.GetPathForALayer(pLay));
pFLay = null;
found = true;
break;
case "N":
inObject.set_Value(fieldNum, pLay.Name);
pFLay = null;
found = true;
break;
default:
inObject.set_Value(fieldNum, Globals.GetPathForALayer(pLay));
pFLay = null;
found = true;
//inObject.set_Value(fieldNum, null);
break;
}
}
else
{
AAState.WriteLine(" Does not intersect " + pFLay.Name);
}
}
}
else
{
AAState.WriteLine(" Warning: Unsupported type");
}
pLay = pEnum.Next();
}
pEnum = null;
}
else
{
AAState.WriteLine(" ERROR: not matching layer types found");
}
}
else
AAState.WriteLine(" ERROR: Geo not Found");
}
//if (!(found) && inObject.Fields.get_Field(fieldNum).IsNullable)
// inObject.set_Value(fieldNum, null);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_LAYER_DETAILS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_LAYER_DETAILS");
}
break;
case "INTERSECTING_FEATURE_DISTANCE":
try
{
AAState.WriteLine(" Trying: INTERSECTING_FEATURE_DISTANCE");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
// Parse arguments
args = valData.Split('|');
if (args.GetLength(0) >= 2)
{
// sourceLayerName = args[0].ToString();
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
}
// Get layer
if (sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
sourceLayerName = args[i].ToString();
if (i == 0)
i++;
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName);
if (sourceLayer == null)
{
AAState.WriteLine(" ERROR/WARNING: " + sourceLayer + " was not found");
continue;
}
IFeatureClass iFC = inFeature.Class as IFeatureClass;
if (sourceLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
AAState.WriteLine(" ERROR: " + sourceLayer + " is a polygon layer");
break;
}
//if (sourceLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryPolyline || iFC.ShapeType != esriGeometryType.esriGeometryPoint)
// break;
//FindLayerByName(sourceLayerName, out sourceLayer);
if (sourceLayer != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
sFilter = new SpatialFilterClass();
sFilter.Geometry = inFeature.ShapeCopy;
sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
sourceFeature = fCursor.NextFeature();
if (sourceFeature != null)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
double dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2);
string strUnit = Globals.GetSpatRefUnitName(Globals.GetLayersCoordinateSystem(sourceLayer.FeatureClass), true);
if (strUnit == "Foot" && dAlong != 1)
{
strUnit = "Feet";
}
else if (strUnit == "Meter" && dAlong != 1)
{
strUnit = "Meters";
}
string strDis = dAlong + " " + strUnit + " along " + sourceLayer.Name + " with " + sourceLayer.FeatureClass.Fields.get_Field(sourceField).AliasName + " of " + sourceFeature.get_Value(sourceField);
if (inObject.Fields.get_Field(fieldNum).Length < strDis.Length - 1)
{
strDis = dAlong + " " + strUnit + ": " + sourceFeature.get_Value(sourceField);
AAState.WriteLine(" Text is to long, defaulting to length along: " + strDis);
if (inObject.Fields.get_Field(fieldNum).Length < strDis.Length - 1)
{
if (inObject.Fields.get_Field(fieldNum).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(fieldNum, strDis);
break;
}
else
{
inObject.set_Value(fieldNum, strDis);
break;
}
}
else
{
strDis = dAlong.ToString();
AAState.WriteLine(" Text is to long, defaulting to length along: " + strDis);
if (inObject.Fields.get_Field(fieldNum).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(fieldNum, strDis);
break;
}
else
{
inObject.set_Value(fieldNum, strDis);
break;
}
}
}
else
{
AAState.WriteLine(" Value set to: " + strDis);
inObject.set_Value(fieldNum, strDis);
break;
}
}
else if (inObject.Fields.get_Field(fieldNum).IsNullable)
inObject.set_Value(fieldNum, null);
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayer + ": field: " + sourceFieldName + " was not found");
}
}
else { }
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_FEATURE_DISTANCE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_FEATURE_DISTANCE");
}
break;
//Release: 1.2
//New Dynamic Value Method: NEARSET_FEATURE - similiar to INTERSECTING_FEATURE but requires a search distance.
case "NEAREST_FEATURE":
try
{
AAState.WriteLine(" Trying: NEAREST_FEATURE");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
searchDistance = 0;
found = false;
// Parse arguments
args = valData.Split('|');
if (args.GetLength(0) > 1)
{
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
}
if (args.GetLength(0) > 2)
Double.TryParse(args[2], out searchDistance);
if (sourceLayerNames.Length > 0 & sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName) as IFeatureLayer;
if (sourceLayer != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
sFilter = new SpatialFilterClass();
if (searchDistance > 0)
{
searchEnvelope = inFeature.ShapeCopy.Envelope;
searchEnvelope.Expand(searchDistance, searchDistance, false);
sFilter.Geometry = searchEnvelope;
}
else
sFilter.Geometry = inFeature.ShapeCopy;
sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
fCursor = sourceLayer.FeatureClass.Search(sFilter, false);
sourceFeature = fCursor.NextFeature();
nearestFeature = null;
proxOp = (IProximityOperator)inFeature.Shape;
lastDistance = searchDistance;
while (!(sourceFeature == null))
{
distance = proxOp.ReturnDistance(sourceFeature.Shape);
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
sourceFeature = fCursor.NextFeature();
}
if (nearestFeature != null)
{
inObject.set_Value(fieldNum, nearestFeature.get_Value(sourceField));
found = true;
break;
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayer + ": field: " + sourceFieldName + " was not found");
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayer + " was not found");
}
}
else
{
AAState.WriteLine(" ERROR: Empty source layer name");
}
}
if (!found)
{
IField field = inObject.Fields.get_Field(fieldNum);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(fieldNum, null);
}
}
else
{
inObject.set_Value(fieldNum, newval);
}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: NEAREST_FEATURE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: NEAREST_FEATURE");
}
break;
default:
// MessageBox.Show(valMethod + " for layer " + tableName + " is not a valid method, check the dynamic value table", "Attribute Assistant");
AAState.WriteLine("ERROR: " + valMethod + " for layer " + tableName + " is not a valid method, check the dynamic value table");
break;
}
}
catch (Exception ex)
{
MessageBox.Show("TableName:" + tableName + " FieldName:" + fieldName + System.Environment.NewLine + "ValueMethod:" + valMethod + " ValueData:" + valData + System.Environment.NewLine + "Message: " + ex.Message, "Attribute Assistant Message");
AAState.WriteLine("ERROR: TableName:" + tableName + " FieldName:" + fieldName + System.Environment.NewLine + "ValueMethod:" + valMethod + " ValueData:" + valData + System.Environment.NewLine + "Message: " + ex.Message);
}
}
// if (mode == "ON_CREATE")
//{
if (inObject != null)
{
inChanges = inObject as IRowChanges;
if (fieldNum < inObject.Fields.FieldCount)
{
changed = inChanges.get_ValueChanged(fieldNum);
if (changed)
// if (fieldName.ToUpper() != "SHAPE")
try
{
// AAState.WriteLine(" Setting Last Value");
if (AAState.lastValueProperties.GetProperty(fieldName) != null)
{
AAState.WriteLine(" Setting Last Value");
AAState.WriteLine(" " + fieldName + ": " + inObject.get_Value(fieldNum).ToString());
AAState.lastValueProperties.SetProperty(fieldName, inObject.get_Value(fieldNum));
}
else
{
AAState.WriteLine(" Setting Last Value");
AAState.WriteLine(" " + fieldName + ": " + inObject.get_Value(fieldNum).ToString());
AAState.lastValueProperties.SetProperty(fieldName, inObject.get_Value(fieldNum));
}
}
catch
{
//AAState.WriteLine(" Error Setting Last Value " + inObject.Fields.get_Field(fieldNum).Name);
}
//}
}
}
}
}
}
}
catch (Exception ex)
{
MessageBox.Show("Problem in setup." + System.Environment.NewLine + "Message:" + ex.Message, "Attribute Assistant Message");
AAState.WriteLine("Error in setup");
}
finally
{
if (AAState._tab == inObject.Class)
{
AAState.reInitExt();
}
if (progressDialog != null)
{
progressDialog.HideDialog();
}
AAState.WriteLine("DONE");
AAState.WriteLine("---------------------------------------");
if (fCursor != null)
{
Marshal.ReleaseComObject(fCursor);
GC.Collect(300);
GC.WaitForFullGCComplete();
}
}
}
public IFeatureClass exportFeatures(IFeatureClass inputFeatureClass, string outPath, ISpatialFilter filter)
{
// Create a name object for the source (shapefile) workspace and open it.
IDataset inDset = (IDataset)inputFeatureClass;
IWorkspace sourceWorkspace = (inDset).Workspace;
// Create a name object for the target (file GDB) workspace and open it.
string outDbStr = geoUtil.parseDbStr(outPath);
string outName = System.IO.Path.GetFileName(outPath);
IWorkspace targetWorkspace = geoUtil.OpenWorkSpace(outDbStr);
outName = geoUtil.getSafeOutputNameNonRaster(targetWorkspace, outName);
// Create a name object for the source dataset.
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.Name = inDset.Name;
sourceDatasetName.WorkspaceName = (IWorkspaceName)((IDataset)sourceWorkspace).FullName;
// Create a name object for the target dataset.
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = outName;
targetDatasetName.WorkspaceName = (IWorkspaceName)((IDataset)targetWorkspace).FullName; ;
// Open source feature class to get field definitions.
//IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = inputFeatureClass;
// Create the objects and references necessary for field validation.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFields = sourceFeatureClass.Fields;
IFields targetFields = null;
IEnumFieldError enumFieldError = null;
// Set the required properties for the IFieldChecker interface.
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
// Validate the fields and check for errors.
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError != null)
{
// Handle the errors in a way appropriate to your application.
Console.WriteLine("Errors were encountered during field validation.");
}
// Find the shape field.
String shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
// Get the geometry definition from the shape field and clone it.
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
// Cast the IGeometryDef to the IGeometryDefEdit interface.
IGeometryDefEdit targetGeometryDefEdit = (IGeometryDefEdit)targetGeometryDef;
// Set the IGeometryDefEdit properties.
targetGeometryDefEdit.GridCount_2 = 1;
targetGeometryDefEdit.set_GridSize(0, 0.75);
// Create the converter and run the conversion.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass(sourceFeatureClassName, filter, null, targetFeatureClassName, targetGeometryDef, targetFields, "", 1000, 0);
// Check for errors.
IInvalidObjectInfo invalidObjectInfo = null;
enumInvalidObject.Reset();
while ((invalidObjectInfo = enumInvalidObject.Next()) != null)
{
// Handle the errors in a way appropriate to the application.
Console.WriteLine("Errors occurred for the following feature: {0}", invalidObjectInfo.InvalidObjectID);
}
return (IFeatureClass)((IName)targetFeatureClassName).Open();
}
protected override void OnShutdown()
{
try
{
script = null;
lastValue = null;
areaLayer = null;
intersectLayer = null;
intersectTable = null;
intersectLayerSelection = null;
intersectTableSelection = null;
qFilter = null;
row = null;
testField = null;
curve = null;
sourceLayer = null;
pFS = null;
_copyPoint = null;
_copyPolyline = null;
_copyPolygon = null;
sFilter = null;
try
{
if (fCursor != null)
Marshal.ReleaseComObject(fCursor);
if (cCurs != null)
Marshal.ReleaseComObject(cCurs);
if (sourceFeature != null)
Marshal.ReleaseComObject(sourceFeature);
}
catch
{ }
fCursor = null;
cCurs = null;
sourceFeature = null;
nearestFeature = null;
fieldObj = null;
_currentDataset = null;
proxOp = null;
}
catch { }
try
{
if (AAState._sw != null)
{
AAState._sw.Flush();
AAState._sw.Close();
AAState._sw = null;
}
}
catch { }
try
{
//ESRI.ArcGIS.ArcMap.IApplicationStatusEvents_Event appStatusEvents = ArcMap.Application as ESRI.ArcGIS.ArcMap.IApplicationStatusEvents_Event;
//appStatusEvents.Initialized -= new ESRI.ArcGIS.ArcMap.IApplicationStatusEvents_InitializedEventHandler(appStatusEvents_Initialized);
if (ArcMap.Events != null)
{
ArcMap.Events.NewDocument -= ArcMap_NewOpenDocument;
ArcMap.Events.OpenDocument -= ArcMap_NewOpenDocument;
}
if (AAState._editor != null)
{
if (AAState._editor != null)
{
//Wire editor events.
AAState._editEvents = (IEditEvents_Event)AAState._editor;
AAState._editEvents.OnStartEditing -= OnStartEditing;
AAState._editEvents.OnStopEditing -= OnStopEditing;
AAState._editor = null;
AAState._editEvents = null;
}
}
try
{
AAState.bmpOff.Dispose();
AAState.bmpOn.Dispose();
AAState.commandItem = null;
}
catch { }
}
catch (Exception ex)
{
MessageBox.Show("OnShutdown: " + ex.Message);
}
}
protected override void OnShutdown()
{
try
{
script = null;
lastValue = null;
intersectLayer = null;
intersectTable = null;
intersectLayerSelection = null;
intersectTableSelection = null;
qFilter = null;
row = null;
testField = null;
curve = null;
sourceLayer = null;
pFS = null;
_copyPoint = null;
_copyPolyline = null;
_copyPolygon = null;
sFilter = null;
try
{
if (fCursor != null)
Marshal.ReleaseComObject(fCursor);
if (cCurs != null)
Marshal.ReleaseComObject(cCurs);
if (sourceFeature != null)
Marshal.ReleaseComObject(sourceFeature);
}
catch
{ }
fCursor = null;
cCurs = null;
sourceFeature = null;
nearestFeature = null;
fieldObj = null;
_currentDataset = null;
proxOp = null;
}
catch { }
try
{
if (AAState._sw != null)
{
AAState._sw.Flush();
AAState._sw.Close();
AAState._sw = null;
}
}
catch { }
try
{
if (ArcMap.Events != null)
{
ArcMap.Events.NewDocument -= ArcMap_NewOpenDocument;
ArcMap.Events.OpenDocument -= ArcMap_NewOpenDocument;
}
if (AAState._editor != null)
{
if (AAState._editor != null)
{
//Wire editor events.
AAState._editEvents = (IEditEvents_Event)AAState._editor;
AAState._editEvents.OnStartEditing -= OnStartEditing;
AAState._editEvents.OnStopEditing -= OnStopEditing;
AAState._editEvents2 = (IEditEvents2_Event)AAState._editor;// SG Jan 2003
AAState._editor = null;
AAState._editEvents = null;
AAState._editEvents2 = null; // SG Jan 2003
}
}
try
{
AAState.bmpOff.Dispose();
AAState.bmpOn.Dispose();
AAState.commandItem = null;
}
catch { }
}
catch (Exception ex)
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("AttributeAssistantEditorChain5") + ex.Message);
}
}
public bool SetDynamicValues(IObject inObject, string mode, out List<IObject> ChangeFeatureList, out List<IObject> NewFeatureList)
{
ChangeFeatureList = null;
NewFeatureList = null;
IFeature inFeature = null;
// IRow inRow = null;
IMSegmentation mseg = null;
INetworkFeature netFeat = null;
IJunctionFeature iJuncFeat = null;
IEdgeFeature iEdgeFeat = null;
//ProgressBar
ESRI.ArcGIS.Framework.IProgressDialogFactory progressDialogFactory = null;
ESRI.ArcGIS.esriSystem.IStepProgressor stepProgressor = null;
ESRI.ArcGIS.Framework.IProgressDialog2 progressDialog = null;
// Create a CancelTracker
ESRI.ArcGIS.esriSystem.ITrackCancel trackCancel = new ESRI.ArcGIS.Display.CancelTrackerClass();
try
{
if (AAState._PerformUpdates && AAState._dv == null)
{
AAState.WriteLine("Dynamic Value Table is missing - Name in Config:" + AAState._defaultsTableName);
// MessageBox.Show("The Attribute Assistant is turned on, but the Dynamic Value table is missing, please add the table and toggle the extension on");
AAState._PerformUpdates = false;
return false;
}
if (AAState._PerformUpdates && AAState._dv != null)
{
if (inObject == null)
return false;
if (inObject.Table == AAState._tab)
{
AAState.WriteLine("Dynamic Value Table is the table that is edited, skipping");
return false;
}
//Convert row to feature (test for feature is null before using - this could be a table update)
inFeature = inObject as IFeature;
// inRow = inObject as IRow;
string modeVal;
if (AAState._dv.Table.Columns[mode].DataType == System.Type.GetType("System.String"))
{
modeVal = "(" + mode + " = '1' or " + mode + " = 'Yes' or " + mode + " = 'YES' or " + mode + " = 'True' or " + mode + " = 'TRUE')";
}
else
{
modeVal = mode + " = 1";
}
System.Int32 int32_hWnd = ArcMap.Application.hWnd;
progressDialogFactory = new ESRI.ArcGIS.Framework.ProgressDialogFactoryClass();
stepProgressor = progressDialogFactory.Create(trackCancel, int32_hWnd);
stepProgressor.MinRange = 0;
stepProgressor.MaxRange = inObject.Fields.FieldCount;
stepProgressor.StepValue = 1;
stepProgressor.Message = "Attribute Assistant Progress";
// Create the ProgressDialog. This automatically displays the dialog
progressDialog = (ESRI.ArcGIS.Framework.IProgressDialog2)stepProgressor; // Explict Cast
// Set the properties of the ProgressDialog
progressDialog.CancelEnabled = true;
progressDialog.Description = "Checking rules for " + inObject.Class.AliasName;
progressDialog.Title = "Attribute Assistant Progress";
progressDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressGlobe;
progressDialog.ShowDialog();
//for each field in this row/feature
// Skip orphan junctions (saves time)
if (Globals.isOrpanJunction(inFeature))
return false;
//Get table name for this feature
_currentDataset = inObject.Class as IDataset;
_currentDatasetNameItems = _currentDataset.Name.Split('.');
tableName = _currentDatasetNameItems[_currentDatasetNameItems.GetLength(0) - 1];
stepProgressor.Message = "Checking rules for edited feature: " + inObject.Class.AliasName;
progressDialog.Description = "Checking rules for edited feature: " + inObject.Class.AliasName;
AAState.WriteLine("***********************************************************");
AAState.WriteLine("############ " + DateTime.Now + " ################");
AAState.WriteLine("");
AAState.WriteLine(" Setting sort order: Field - RUNORDER");
if (AAState._dv.Table.Columns.Contains("RUN_WEIGHT"))
AAState._dv.Sort = "RUN_WEIGHT DESC";
AAState.WriteLine(" Querying table for Last Value for layer: " + inObject.Class.AliasName);
AAState.WriteLine(" Query Used: (TABLENAME = '*' OR TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') AND VALUEMETHOD = 'Last_Value'");
AAState._dv.RowFilter = "(TABLENAME = '*' OR TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') AND VALUEMETHOD = 'Last_Value'";
AAState.WriteLine(" Number of results: " + AAState._dv.Count.ToString());
if (AAState._dv.Count > 0)
{
IRowChanges pRowChLast = inObject as IRowChanges;
for (int retRows = 0; retRows < AAState._dv.Count; retRows++)
{
DataRowView drv = AAState._dv[retRows];
AAState.WriteLine(" Looking for " + drv["FIELDNAME"].ToString());
int fldLoc = inObject.Fields.FindField(drv["FIELDNAME"].ToString());
if (fldLoc > 0)
{
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + " field found at position: " + fldLoc);
if (pRowChLast.get_ValueChanged(fldLoc))
{
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + " Has Changed");
try
{
if (inObject.get_Value(fldLoc) != null)
{
if (inObject.get_Value(fldLoc) != DBNull.Value)
{
if (AAState.lastValueProperties.GetProperty(drv["FIELDNAME"].ToString()) != null)
{
AAState.WriteLine(" Setting Last Value");
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + ": " + inObject.get_Value(fldLoc).ToString());
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), inObject.get_Value(fldLoc));
}
else
{
AAState.WriteLine(" Setting Last Value");
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + ": " + inObject.get_Value(fldLoc));
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), inObject.get_Value(fldLoc));
}
}
else
{
if (mode == "ON_CREATE")
{
AAState.WriteLine(" Skipping null on create");
}
else
{
AAState.WriteLine(" Setting Last Value");
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + ": NULL");
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), null);
}
}
}
else
{
if (mode == "ON_CREATE")
{
AAState.WriteLine(" Skipping null on create");
}
else
{
AAState.WriteLine(" Setting Last Value");
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + ": NULL");
AAState.lastValueProperties.SetProperty(drv["FIELDNAME"].ToString(), null);
}
}
}
catch
{
//AAState.WriteLine(" Error Setting Last Value " + inObject.Fields.get_Field(intFldIdxs[0]).Name);
}
}
else
{
AAState.WriteLine(" " + drv["FIELDNAME"].ToString() + " Has not changed");
}
}
}
pRowChLast = null;
// pRowChLast.
}
//if (inObject != null)
//{
// inChanges = inObject as IRowChanges;
// if (intFldIdxs.Count > 0)
// {
// if (intFldIdxs[0] > -1)
// {
// changed = inChanges.get_ValueChanged(intFldIdxs[0]);
// if (changed)
// // if (fieldName.ToUpper() != "SHAPE")
// try
// {
// // if (AAState.lastValueProperties.
// // AAState.WriteLine(" Setting Last Value");
// if (AAState.lastValueProperties.GetProperty(strFldNames[0]) != null)
// {
// AAState.WriteLine(" Setting Last Value");
// AAState.WriteLine(" " + strFldNames[0] + ": " + inObject.get_Value(intFldIdxs[0]).ToString());
// AAState.lastValueProperties.SetProperty(strFldNames[0], inObject.get_Value(intFldIdxs[0]));
// }
// else
// {
// AAState.WriteLine(" Setting Last Value");
// AAState.WriteLine(" " + strFldNames[0] + ": " + inObject.get_Value(intFldIdxs[0]).ToString());
// AAState.lastValueProperties.SetProperty(strFldNames[0], inObject.get_Value(intFldIdxs[0]));
// }
// }
// catch
// {
// //AAState.WriteLine(" Error Setting Last Value " + inObject.Fields.get_Field(intFldIdxs[0]).Name);
// }
// }
// }
//}
AAState.WriteLine(" Querying table for rules for layer: " + inObject.Class.AliasName);
AAState.WriteLine(" Query Used: (TABLENAME = '*' OR TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') AND " + modeVal);
AAState._dv.RowFilter = "(TABLENAME = '*' OR TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') AND " + modeVal;
AAState.WriteLine(" Number of results: " + AAState._dv.Count.ToString());
//AAState._processCount;
if (AAState._processCount > 2)
{
System.Threading.Thread.Sleep(400);
}
if (AAState._processCount > 15)
{
MessageBox.Show("You have more than 15 processes running, more than likely your rules are causing an infinite loop. Any rule that creates a new feature with * as the table name can cause this issue.");
return false;
}
if (AAState._dv.Count > 0)
{
bool proc = false;
AAState.WriteLine(" Looping through the rows");
for (int retRows = 0; retRows < AAState._dv.Count; retRows++)
{
DataRowView drv = AAState._dv[retRows];
AAState.WriteLine(" ------------------------------------------------");
AAState.WriteLine(" Row Info");
AAState.WriteLine(" Row Number " + (retRows + 1).ToString());
AAState.WriteLine(" TableName: " + drv["TABLENAME"].ToString());
AAState.WriteLine(" FieldName: " + drv["FIELDNAME"].ToString());
AAState.WriteLine(" ValueInfo: " + drv["VALUEINFO"].ToString());
AAState.WriteLine(" ValueMethod: " + drv["VALUEMETHOD"].ToString());
AAState.WriteLine(" On Create: " + drv["ON_CREATE"].ToString());
AAState.WriteLine(" On Change: " + drv["ON_CHANGE"].ToString());
if (AAState._dv.Table.Columns.Contains("RUNORDER"))
AAState.WriteLine(" Order: " + drv["RUNORDER"].ToString());
AAState.WriteLine("");
AAState.WriteLine(" Checking for Subtype Restriction");
valFC = drv["TABLENAME"].ToString().Trim();
if (valFC.Contains("|"))
{
AAState.WriteLine(" Subtype restriction Found");
string[] spliVal = valFC.Split('|');
List<string> validSubtypes = new List<string>(spliVal[1].Split(','));
List<string> inValidSubtypes;
if (spliVal.GetLength(0) == 3)
{
inValidSubtypes = new List<string>(spliVal[2].Split(','));
}
else
{
inValidSubtypes = new List<string>();
}
int obSubVal;
ISubtypes pSub = inObject.Class as ISubtypes;
if (pSub != null)
{
if (pSub.HasSubtype)
{
if (inObject.get_Value(pSub.SubtypeFieldIndex).ToString() != "")
{
obSubVal = Convert.ToInt32(inObject.get_Value(pSub.SubtypeFieldIndex).ToString());
if (validSubtypes.Contains("*"))
{
if (inValidSubtypes.Contains(obSubVal.ToString()))
{
AAState.WriteLine(" Skipping, not the subtype defined");
proc = false;
continue;
}
else
{
AAState.WriteLine(" Subtype is valid");
}
}
else if (validSubtypes.Contains(obSubVal.ToString()))
{
AAState.WriteLine(" Subtype is valid");
}
else
{
AAState.WriteLine(" Skipping, not the subtype defined");
proc = false;
continue;
}
}
else
{
AAState.WriteLine(" Skipping, subtype is not set");
proc = false;
continue;
}
}
else
{
AAState.WriteLine(" ERROR: Layer does not have subtypes");
}
}
else
{
AAState.WriteLine(" ERROR: Layer does not have subtypes");
}
}
valMethod = drv["VALUEMETHOD"].ToString().ToUpper().Trim();
valData = drv["VALUEINFO"].ToString().Trim();
if (valData.Contains(Environment.NewLine))
{
valData = valData.Substring(0, valData.IndexOf(Environment.NewLine));
}
List<string> strFldNames = new List<string>();
List<int> intFldIdxs = new List<int>();
fieldObj = null;
if (drv["FIELDNAME"] != null && drv["FIELDNAME"].ToString().Trim() != "" && drv["FIELDNAME"].ToString().Trim() != "*" && drv["FIELDNAME"].ToString().Trim() != "#")
{
strFldNames = new List<string>(drv["FIELDNAME"].ToString().Trim().Split(','));
foreach (string strFldName in strFldNames)
{
if (inObject.Fields.FindField(strFldName) >= 0)
{
int tem = inObject.Fields.FindField(strFldName);
intFldIdxs.Add(tem);
fieldObj = inObject.Fields.get_Field(tem);
AAState.WriteLine(" Field Name: " + strFldName + " was found at index: " + tem);
proc = true;
}
else if (inObject.Fields.FindFieldByAliasName(strFldName) >= 0)
{
int tem = inObject.Fields.FindFieldByAliasName(strFldName);
intFldIdxs.Add(tem);
fieldObj = inObject.Fields.get_Field(tem);
AAState.WriteLine(" Field Name: " + strFldName + " was found at index: " + tem);
proc = true;
}
else
{
intFldIdxs.Add(-1);
AAState.WriteLine(" " + strFldName + " Field not found");
// strFldNames.Remove
fieldObj = null;
proc = false;
}
}
}
else if (drv["FIELDNAME"].ToString() == "#")
{
AAState.WriteLine(" Field is set to edited field");
IRowChanges pRowCh = null;
IField pTmpFld = null;
pRowCh = inObject as IRowChanges;
for (int i = 0; i < inObject.Fields.FieldCount; i++)
{
pTmpFld = inObject.Fields.get_Field(i);
if (pTmpFld.Type != esriFieldType.esriFieldTypeGlobalID &&
pTmpFld.Type != esriFieldType.esriFieldTypeOID &&
pTmpFld.Type != esriFieldType.esriFieldTypeGeometry &&
pTmpFld.Name.ToUpper() != "SHAPE_LENGTH" &&
pTmpFld.Name.ToUpper() != "SHAPE.LEN" &&
pTmpFld.Name.ToUpper() != "SHAPE_AREA" &&
pTmpFld.Name.ToUpper() != "SHAPE.AREA")
{
if (pRowCh.get_ValueChanged(i) == true)
{
AAState.WriteLine(" Adding " + pTmpFld.Name + " to field array");
strFldNames.Add(pTmpFld.Name);
intFldIdxs.Add(i);
proc = true;
}
}
}
pRowCh = null;
pTmpFld = null;
}
else
{
AAState.WriteLine(" Field is not specified, empty, or set for all.");
fieldObj = null;
proc = true;
}
if (proc)
{
try
{
switch (valMethod)
{
case "FIELD_TRIGGER"://Value|FieldToChange|Value
try
{
AAState.WriteLine(" Trying: FIELD_TRIGGER");
if (inFeature != null & valData != null)
{
// Parse arguments
args = valData.Split('|');
string valToCheck = "";
string fldToChange = "";
string valToSet = "";
if (args.GetLength(0) == 3)
{
valToCheck = args[0];
fldToChange = args[1];
valToSet = args[2];
}
else
{
AAState.WriteLine(" ERROR: Incorrect Value info was not found");
continue;
}
IRowChanges pRowCh = null;
pRowCh = inObject as IRowChanges;
//Globals.GetFieldIndex(inObject.Fields,
if (intFldIdxs.Count == 0)
{
AAState.WriteLine(" ERROR: Field Not Set");
continue;
}
if (intFldIdxs[0] == -1)
{
AAState.WriteLine(" ERROR: Field Not Found");
continue;
}
if (pRowCh.get_ValueChanged(intFldIdxs[0]))
{
AAState.WriteLine(" Listed field changed");
if (inObject.get_Value(intFldIdxs[0]).ToString() == valToCheck)
{
AAState.WriteLine(" Values Match");
int chngFldIdx = Globals.GetFieldIndex(inObject.Fields, fldToChange);
if (chngFldIdx == -1)
{
AAState.WriteLine(" ERROR: Field Not Found");
continue;
}
try
{
inObject.set_Value(chngFldIdx, valToSet);
AAState.WriteLine(" Value Set");
}
catch
{
AAState.WriteLine(" ERROR: Could not store Value: " + valToSet);
}
}
}
pRowCh = null;
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: FIELD_TRIGGER: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: FIELD_TRIGGER");
}
break;
case "VALIDATE_ATTRIBUTE_LOOKUP":
{
AAState.WriteLine(" Trying VALIDATE_ATTRIBUTE_LOOKUP");
IRowChanges pRowCh = null;
ISQLSyntax sqlSyntax = null;
IQueryFilter pQFilt = null;
try
{
if ((valData != null) && (inFeature != null))
{
pRowCh = inObject as IRowChanges;
bool valueChanged = false;
for (int i = 0; i < intFldIdxs.Count; i++)
{
if (pRowCh.get_ValueChanged(intFldIdxs[i]) == true)
{
valueChanged = true;
break;
}
}
if (valueChanged == false)
{
AAState.WriteLine(" VALIDATE_ATTRIBUTE_LOOKUP: Target value(s) did not change, skipping");
continue;
}
sourceLayerName = "";
string[] sourceFieldNames = null;
//string[] destFieldNames = null;
// Parse arguments
args = valData.Split('|');
if (args.Length == 2)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
}
else
{
AAState.WriteLine(" ERROR: the valuemethod is not defined properly for this rule");
continue;
}
if ((sourceFieldNames != null) &&
(sourceFieldNames.Length > 0))
{
AAState.WriteLine(" Looking for layer: " + sourceLayerName);
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
}
IFields pFlds = null;
//IWorkspace pWork = null;
IDataset pDs = null;
string layNameFnd = "";
bool matchingLayFnd = false;
IStandaloneTable pTbl = null;
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
pFlds = sourceLayer.FeatureClass.Fields;
pDs = sourceLayer.FeatureClass as IDataset;
layNameFnd = sourceLayer.Name;
matchingLayFnd = true;
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " data source is not set");
continue;
}
}
else
{
pTbl = Globals.FindStandAloneTable(AAState._editor.Map, sourceLayerName) as IStandaloneTable;
if (pTbl != null)
{
if (pTbl.Table != null)
{
pFlds = pTbl.Table.Fields;
pDs = pTbl.Table as IDataset;
layNameFnd = pTbl.Name;
matchingLayFnd = true;
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " data source is not set");
continue;
}
}
if (matchingLayFnd == false)
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " was not found");
continue;
}
sqlSyntax = (ISQLSyntax)(pDs.Workspace);
string specChar = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_WildcardManyMatch);
AAState.WriteLine(" Lookup layer " + layNameFnd + " was Found: " + sourceLayerName);
AAState.WriteLine(" Checking for field in Lookup table");
// string missingFieldMess = null;
if (sourceFieldNames.Length != intFldIdxs.Count)
{
AAState.WriteLine(" Number of listed fields do not match");
continue;
}
int[] sourceFieldNums = new int[sourceFieldNames.Length];
// missingFieldMess = "";
pQFilt = new QueryFilterClass();
string sqlString = "";
string sqlStringUpper = "";
for (int i = 0; i < sourceFieldNames.Length; i++)
{
sourceFieldNums[i] = Globals.GetFieldIndex(pFlds, sourceFieldNames[i].Trim());
if (sourceFieldNums[i] < 0)
{
AAState.WriteLine(" Fields Missing: " + sourceFieldName[i]);
break;
}
if (pFlds.get_Field(sourceFieldNums[i]).Type == esriFieldType.esriFieldTypeString)
{
if (sqlString == "")
{
sqlString = pFlds.get_Field(sourceFieldNums[i]).Name + "" + " = '" + inObject.get_Value(intFldIdxs[i]).ToString() + "'";
sqlStringUpper = "UPPER(" + pFlds.get_Field(sourceFieldNums[i]).Name + ")" + " LIKE '" + specChar + inObject.get_Value(intFldIdxs[i]).ToString().ToUpper().Replace(" ", specChar) + specChar + "'";
}
else
{
sqlString = sqlString + " AND " + pFlds.get_Field(sourceFieldNums[i]).Name + "" + " = '" + inObject.get_Value(intFldIdxs[i]).ToString() + "'";
sqlStringUpper = sqlStringUpper + " AND " + "UPPER(" + pFlds.get_Field(sourceFieldNums[i]).Name + ")" + " LIKE '" + specChar + inObject.get_Value(intFldIdxs[i]).ToString().ToUpper().Replace(" ", specChar) + specChar + "'";
}
}
else
{
if (sqlString == "")
{
sqlString = pFlds.get_Field(sourceFieldNums[i]).Name + " = " + inObject.get_Value(intFldIdxs[i]);
sqlStringUpper = pFlds.get_Field(sourceFieldNums[i]).Name + " LIKE " + specChar + inObject.get_Value(intFldIdxs[i]) + specChar;
}
else
{
sqlString = sqlString + " AND " + pFlds.get_Field(sourceFieldNums[i]).Name + " = " + inObject.get_Value(intFldIdxs[i]);
sqlStringUpper = sqlStringUpper + " AND " + pFlds.get_Field(sourceFieldNums[i]).Name + " LIKE " + specChar + inObject.get_Value(intFldIdxs[i]) + specChar;
}
}
}
pQFilt.WhereClause = sqlString;
//if (inObject.get_Value(intFldIdxs[0]).ToString().Trim() == "")
//{
// if (mode == "ON_CREATE")
// {
// AAState.WriteLine(" Field Found");
// continue;
// }
// pQFilt.WhereClause = "1=1";
//}
//else
//{
//}
AAState.WriteLine(" " + pQFilt.WhereClause + " used to search for matching record");
int intRecFound = 0;
if (sourceLayer == null)
{
intRecFound = pTbl.Table.RowCount(pQFilt);
}
else
{
intRecFound = sourceLayer.FeatureClass.FeatureCount(pQFilt);
}
AAState.WriteLine(" " + intRecFound + " rows found");
if (intRecFound != 1)
{
//if (inObject.get_Value(intFldIdxs[0]).ToString().Trim() == "")
//{
// pQFilt.WhereClause = "1=1";
//}
//else
//{
pQFilt.WhereClause = sqlStringUpper;
// }
AAState.WriteLine(" " + pQFilt.WhereClause + " used to search for matching record");
if (sourceLayer == null)
{
intRecFound = pTbl.Table.RowCount(pQFilt);
}
else
{
intRecFound = sourceLayer.FeatureClass.FeatureCount(pQFilt);
}
AAState.WriteLine(" " + intRecFound + " rows found");
if (intRecFound == 0)
{
AAState.WriteLine(" Abort Edit");
AAState._editor.AbortOperation();
return false;
}
else
{
AAState.WriteLine(" Prompting for user input");
ICursor pCurs = null;
if (sourceLayer == null)
{
pCurs = pTbl.Table.Search(pQFilt, true);
}
else
{
pCurs = sourceLayer.FeatureClass.Search(pQFilt, true) as ICursor;
}
pQFilt = null;
List<string> pLst = Globals.CursorToList(ref pCurs, sourceFieldNums);
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
string selectVal = Globals.showOptionsForm(pLst, "Select an value to store", ComboBoxStyle.DropDownList);
if (selectVal == "||Cancelled||")
{
AAState.WriteLine(" Abort Edit");
AAState._editor.AbortOperation();
return false;
}
else
{
AAState.WriteLine(" Value selected: " + selectVal);
string[] strVals = selectVal.Split('|');
for (int i = 0; i < sourceFieldNums.Length; i++)
{
inObject.set_Value(intFldIdxs[i], strVals[i]);
}
}
}
}
else
{
AAState.WriteLine(" One Exact match was found");
}
pQFilt = null;
}
else
{
AAState.WriteLine(" ERROR: Invalid Value Info: " + valData);
}
}
else
{
AAState.WriteLine(" ERROR: Not a feature or missing Value Info");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: VALIDATE_ATTRIBUTE_LOOKUP" + Environment.NewLine + ex.Message);
}
finally
{
pQFilt = null;
sqlSyntax = null;
pRowCh = null;
AAState.WriteLine(" Finished: VALIDATE_ATTRIBUTE_LOOKUP");
}
break;
}
case "ANGLE":
try
{
AAState.WriteLine(" Trying: ANGLE");
if (inFeature != null)
{
if (intFldIdxs.Count == 0)
{
AAState.WriteLine(" Field not found");
continue;
}
if ((inFeature.Class as IFeatureClass).ShapeType != esriGeometryType.esriGeometryPolyline)
{
AAState.WriteLine(" Input feature is not a line");
continue;
}
bool boolGeo = true;
if (valData.Trim() != "")
{
if (valData.ToUpper() == "A")
{
boolGeo = false;
}
}
AAState.WriteLine(" Getting Angle for feature");
IPolyline pLyLine = inFeature.Shape as IPolyline;
ILine pLine = new LineClass();
pLine.ToPoint = pLyLine.FromPoint;
pLine.FromPoint = pLyLine.ToPoint;
double angArth = pLine.Angle * 180 / Math.PI;
if (angArth < 0)
{
angArth = 360 + angArth;
}
double angGeo = 270 - angArth;
if (angGeo < 0)
{
angGeo = 360 + angGeo;
}
double ang;
if (boolGeo)
{
ang = angGeo;
}
else
{
ang = angArth;
}
AAState.WriteLine(" Angle Calculated: " + ang);
try
{
inObject.set_Value(intFldIdxs[0], ang);
AAState.WriteLine(" Angle Stored");
}
catch
{
AAState.WriteLine(" Could not store angle");
}
pLine = null;
pLyLine = null;
AAState.WriteLine(" Done");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: ANGLE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: ANGLE");
}
break;
case "CREATE_PERP_LINE"://Layer to Search For|Offset Distante or Field|Search distance to look for a line|UseSnapPoint|TargetLayer|TargetLayerTemplate
try
{
AAState.WriteLine(" Trying: CREATE_PERP_LINE");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
double offsetVal = 5;
bool useSnapPnt = false;
string targetLayerName = "";
IFeatureLayer targetLayer = null;
string targetLayerTemp = "";
// Parse arguments
args = valData.Split('|');
int fldOff = -1;
if (args.GetLength(0) == 6)
{
// sourceLayerName = args[0].ToString();
sourceLayerNames = args[0].ToString().Split(',');
//offsetVal = Convert.ToDouble(args[1]);
if (Globals.IsNumeric(args[1]))
Double.TryParse(args[1], out offsetVal);
else
{
fldOff = Globals.GetFieldIndex(inObject.Fields, args[1]);
}
Double.TryParse(args[2], out searchDistance);
Boolean.TryParse(args[3], out useSnapPnt);
targetLayerName = args[4];
targetLayerTemp = args[5];
}
else if (args.GetLength(0) == 5)
{
// sourceLayerName = args[0].ToString();
sourceLayerNames = args[0].ToString().Split(',');
//offsetVal = Convert.ToDouble(args[1]);
if (Globals.IsNumeric(args[1]))
Double.TryParse(args[1], out offsetVal);
else
{
fldOff = Globals.GetFieldIndex(inObject.Fields, args[1]);
}
Double.TryParse(args[2], out searchDistance);
Boolean.TryParse(args[3], out useSnapPnt);
targetLayerName = args[4];
targetLayerTemp = "";
}
else
{
AAState.WriteLine(" ERROR: Incorrect Value info was not found");
continue;
}
if (intFldIdxs.Count > 0)
{
AAState.WriteLine(" WARNING: Input fields are not used for this tool");
continue;
}
targetLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, targetLayerName, ref boolLayerOrFC);
if (targetLayer == null)
{
AAState.WriteLine(" ERROR: Target layer not found. " + targetLayerName);
continue;
}
if (targetLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryPolyline)
{
AAState.WriteLine(" ERROR: Target layer is not a line layer. " + targetLayerName);
continue;
}
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
sourceLayerName = args[i].ToString();
if (i == 0)
i++;
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer == null)
{
AAState.WriteLine(" ERROR/WARNING: " + sourceLayer + " was not found");
continue;
}
IFeatureClass iFC = inFeature.Class as IFeatureClass;
if (sourceLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
AAState.WriteLine(" ERROR: " + sourceLayer + " is a polygon layer");
break;
}
if (sourceLayer != null)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
IPoint snapPnt = null;
while ((sourceFeature = fCursor.NextFeature()) != null)
{
double dAlong = 0;
if (sourceFeature.Class != inFeature.Class)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
pIntPnt = null;
//AAState.WriteLine(" Value set to: " + strDis);
//inObject.set_Value(intFldIdxs[0], strDis);
//break;
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
pIntPnt = null;
//AAState.WriteLine(" Value set to: " + strDis);
// inObject.set_Value(intFldIdxs[0], strDis);
// break;
}
AAState.WriteLine(" Distance found: " + dAlong);
IPoint pNewPt = new PointClass();
IConstructPoint2 pConsPoint = pNewPt as IConstructPoint2;
if (fldOff != -1)
{
string temp = inObject.get_Value(fldOff).ToString();
if (Globals.IsNumeric(temp))
{
Double.TryParse(temp, out offsetVal);
}
}
AAState.WriteLine(" Offset Value: " + offsetVal);
pConsPoint.ConstructOffset
(sourceFeature.Shape as ICurve, esriSegmentExtension.esriNoExtension, dAlong, false, offsetVal);
AAState.WriteLine(" Offset Constrcuted");
AAState.WriteLine(" Creating Line");
IPolyline pTempLine = new PolylineClass();
if (useSnapPnt && snapPnt != null)
{
if (snapPnt.IsEmpty)
{
AAState.WriteLine(" Using feature Point");
pTempLine.ToPoint = inFeature.ShapeCopy as IPoint;
}
else
{
AAState.WriteLine(" Using Snap Point");
pTempLine.ToPoint = snapPnt;
}
}
else
{
AAState.WriteLine(" Using feature Point");
pTempLine.ToPoint = inFeature.ShapeCopy as IPoint;
}
pTempLine.FromPoint = pNewPt;
AAState.WriteLine(" Line Created");
IEditTemplate pTemp = null;
IFeature pFeat = null;
AAState.WriteLine(" Looking for Edit Template");
if (targetLayerTemp != "")
pTemp = Globals.GetEditTemplate(targetLayerTemp, targetLayer);
if (pTemp != null)
{
AAState.WriteLine(" Template found");
pFeat = Globals.CreateFeature(pTempLine, pTemp, AAState._editor, ArcMap.Application, false, false, false);
}
else
{
AAState.WriteLine(" Template not found and creating a feature without it");
pFeat = Globals.CreateFeature(pTempLine, targetLayer, AAState._editor, ArcMap.Application, false, false, false);
}
AAState.WriteLine(" Feature Created");
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
AAState.WriteLine(" Added to the new feature list");
NewFeatureList.Add(pFeat);
pTemp = null;
pNewPt = null;
pConsPoint = null;
snapPnt = null;
AAState.WriteLine(" Finished");
break;
}
//else if (inObject.Fields.get_Field(intFldIdxs[0]).IsNullable)
// inObject.set_Value(intFldIdxs[0], null);
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: CREATE_PERP_LINE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: CREATE_PERP_LINE");
}
break;
case "AUTONUMBER"://Layer to Search For|Offset Distante or Field|Search distance to look for a line
try
{
AAState.WriteLine(" Trying: AUTONUMBER");
if (inObject != null)
{
if (intFldIdxs.Count == 0)
{
AAState.WriteLine(" Field not found");
continue;
}
AAState.WriteLine(" Getting Max value for Field: " + strFldNames[0]);
string res = Globals.GetFieldStats(inObject.Class as IFeatureClass, strFldNames[0], Globals.statsType.Max);
AAState.WriteLine(" Value returned: " + res);
if (res == "External component has thrown an exception.")
{
AAState.WriteLine(" The field specified was not a numeric field");
}
else
{
if (Globals.IsNumeric(res))
{
AAState.WriteLine(" Value is numeric");
AAState.WriteLine(" Trying to Incriment " + res);
long val = (Convert.ToInt64(res) + 1);
AAState.WriteLine(" Incrimented to " + res);
try
{
AAState.WriteLine(" Trying to set value " + res);
inObject.set_Value(intFldIdxs[0], val);
AAState.WriteLine(" Value set" + res);
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Could not set value: " + ex.Message.ToString());
}
}
else
{
AAState.WriteLine(" Value is not numeric: " + res);
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: AUTONUMBER: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: AUTONUMBER");
}
break;
case "COPY_LINKED_RECORD"://Feature Layer|Field To Copy|Primary Key Field|Foreign Key Field
{
try
{
AAState.WriteLine(" Trying: COPY_LINKED_RECORD");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 4)
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
}
else
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
if (inFeature == null)
{
AAState.WriteLine(" ERROR: The input features is null");
break;
}
string[] targetLayerNames;
string targetFieldName = "";
found = false;
AAState.WriteLine(" Getting Value Info");
targetLayerNames = args[0].ToString().Split(',');
targetFieldName = args[1].ToString();
string targetLayerName = "";
string sourceIDFieldName = args[2].ToString();
string targetIDFieldName = args[3].ToString();
AAState.WriteLine(" Checking values");
if (targetFieldName != null)
{
AAState.WriteLine(" Checking Field in Edited Layer");
int fldIDSourecIdx = inObject.Fields.FindField(sourceIDFieldName);
if (fldIDSourecIdx > -1 && intFldIdxs.Count > 0)
{
if (inObject.get_Value(fldIDSourecIdx) != null && inObject.get_Value(fldIDSourecIdx) != DBNull.Value)
{
if (inObject.get_Value(fldIDSourecIdx).ToString() != "")
{
for (int i = 0; i < targetLayerNames.Length; i++)
{
targetLayerName = targetLayerNames[i].ToString();
if (targetLayerName != "")
{
// Get layer
AAState.WriteLine(" Checking for join record");
bool FCorLayerSource = true;
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, targetLayerName, ref FCorLayerSource);
if (sourceLayer != null)
{
int fldValToCopyIdx = sourceLayer.FeatureClass.Fields.FindField(targetFieldName);
int fldIDTargetIdx = sourceLayer.FeatureClass.Fields.FindField(targetIDFieldName);
if (fldIDTargetIdx > -1 && fldValToCopyIdx > -1)
{
IQueryFilter pQFilt = Globals.createQueryFilter();
if (sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Name + "" + " = '" + inObject.get_Value(fldIDSourecIdx).ToString() + "'";
}
else
{
pQFilt.WhereClause = sourceLayer.FeatureClass.Fields.get_Field(fldIDTargetIdx).Name + " = " + inObject.get_Value(fldIDSourecIdx);
}
IFeatureCursor pCurs;
pCurs = sourceLayer.FeatureClass.Search(pQFilt, true);
IFeature pRow;
while ((pRow = pCurs.NextFeature()) != null)
{
AAState.WriteLine(" Trying to Copy Value from Record");
try
{
inObject.set_Value(intFldIdxs[0], pRow.get_Value(fldValToCopyIdx));
break;
}
catch
{
AAState.WriteLine(" ERROR: Could not Copy: " + inObject.get_Value(fldValToCopyIdx) + " to field: " + strFldNames[0]);
}
pRow = null;
}
pRow = null;
AAState.WriteLine(" Value successfully copied");
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
}
else
{
AAState.WriteLine(" ERROR: ID or Field to populate was not found");
}
}
else
{
ITable pTable = Globals.FindTable(AAState._editor.Map, targetLayerName);
if (pTable != null)
{
int fldValToCopyIdx = pTable.Fields.FindField(targetFieldName);
int fldIDTargetIdx = pTable.Fields.FindField(targetIDFieldName);
if (fldIDTargetIdx > -1 && fldValToCopyIdx > -1)
{
IQueryFilter pQFilt = Globals.createQueryFilter();
if (pTable.Fields.get_Field(fldIDTargetIdx).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + pTable.Fields.get_Field(fldIDTargetIdx).Name + "" + " = '" + inObject.get_Value(fldIDSourecIdx).ToString() + "'";
}
else
{
pQFilt.WhereClause = pTable.Fields.get_Field(fldIDTargetIdx).Name + " = " + inObject.get_Value(fldIDSourecIdx);
}
ICursor pCurs;
pCurs = pTable.Search(pQFilt, true);
IRow pRow;
while ((pRow = pCurs.NextRow()) != null)
{
AAState.WriteLine(" Trying to Copy Value from Record");
try
{
inObject.set_Value(intFldIdxs[0], pRow.get_Value(fldValToCopyIdx));
break;
}
catch
{
AAState.WriteLine(" ERROR: Could not Copy: " + inObject.get_Value(fldValToCopyIdx) + " to field: " + strFldNames[0]);
}
pRow = null;
}
pRow = null;
AAState.WriteLine(" Value successfully copied");
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
}
else
{
AAState.WriteLine(" ERROR: ID or Field to populate was not found");
}
}
else
{
AAState.WriteLine(" ERROR: Table to populate not found: " + sourceLayerName);
}
pTable = null;
}
}
}
}
}
}
else
{
AAState.WriteLine(" ERROR: ID or Field to Copy was not found");
}
//if ((!found) && (inObject.Fields.get_Field(intFldIdxs[0]).IsNullable))
//{
// inObject.set_Value(intFldIdxs[0], null);
//}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: COPY_LINKED_RECORD" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: COPY_LINKED_RECORD");
// intFldIdxs[0] = -1;
}
break;
}
case "OFFSET"://Layer to Search For|Offset Distante or Field|Search distance to look for a line
try
{
AAState.WriteLine(" Trying: OFFSET");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
double offsetVal = 5;
// Parse arguments
args = valData.Split('|');
int fldOff = -1;
if (args.GetLength(0) >= 3)
{
// sourceLayerName = args[0].ToString();
sourceLayerNames = args[0].ToString().Split(',');
//offsetVal = Convert.ToDouble(args[1]);
if (Globals.IsNumeric(args[1]))
Double.TryParse(args[1], out offsetVal);
else
{
fldOff = Globals.GetFieldIndex(inObject.Fields, args[1]);
}
Double.TryParse(args[2], out searchDistance);
}
else if (args.GetLength(0) >= 2)
{
// sourceLayerName = args[0].ToString();
sourceLayerNames = args[0].ToString().Split(',');
//offsetVal = Convert.ToDouble(args[1]);
if (Globals.IsNumeric(args[1]))
Double.TryParse(args[1], out offsetVal);
else
{
fldOff = Globals.GetFieldIndex(inObject.Fields, args[1]);
}
Double.TryParse("1", out searchDistance);
}
else
{
AAState.WriteLine(" ERROR: Incorrect Value info was not found");
continue;
}
if (intFldIdxs.Count != 2)
{
AAState.WriteLine(" ERROR: 2 fields in fieldname are required for this tool");
continue;
}
// Get layer
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
sourceLayerName = args[i].ToString();
if (i == 0)
i++;
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer == null)
{
AAState.WriteLine(" ERROR/WARNING: " + sourceLayer + " was not found");
continue;
}
IFeatureClass iFC = inFeature.Class as IFeatureClass;
if (sourceLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
AAState.WriteLine(" ERROR: " + sourceLayer + " is a polygon layer");
break;
}
if (sourceLayer != null)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
while ((sourceFeature = fCursor.NextFeature()) != null)
{
double dAlong = 0;
if (sourceFeature.Class != inFeature.Class)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
IPoint snapPnt = null;
dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
snapPnt = null;
pIntPnt = null;
//AAState.WriteLine(" Value set to: " + strDis);
//inObject.set_Value(intFldIdxs[0], strDis);
//break;
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
IPoint snapPnt = null;
dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
snapPnt = null;
pIntPnt = null;
//AAState.WriteLine(" Value set to: " + strDis);
// inObject.set_Value(intFldIdxs[0], strDis);
// break;
}
AAState.WriteLine(" Distance found: " + dAlong);
IPoint pNewPt = new PointClass();
IConstructPoint2 pConsPoint = pNewPt as IConstructPoint2;
if (fldOff != -1)
{
string temp = inObject.get_Value(fldOff).ToString();
if (Globals.IsNumeric(temp))
{
Double.TryParse(temp, out offsetVal);
}
}
pConsPoint.ConstructOffset
(sourceFeature.Shape as ICurve, esriSegmentExtension.esriNoExtension, dAlong, false, offsetVal);
inObject.set_Value(intFldIdxs[0], pNewPt.X);
inObject.set_Value(intFldIdxs[1], pNewPt.Y);
pNewPt = null;
pConsPoint = null;
}
//else if (inObject.Fields.get_Field(intFldIdxs[0]).IsNullable)
// inObject.set_Value(intFldIdxs[0], null);
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: OFFSET: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: OFFSET");
}
break;
case "SIDE":
{
AAState.WriteLine(" Trying: SIDE");
try
{
//Layer|IDField|IDField source
if ((valData != null) && (inFeature != null))
{
AAState.WriteLine(" Feature and valueinfo is valid");
AAState.WriteLine(" Splitting up value info: " + valData);
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
string inputFieldName = "";
args = valData.Split('|');
if (args.Length < 2)
{
AAState.WriteLine(" ERROR: SIDE: Value info does not have enough parameters");
continue;
}
switch (args.Length)
{
case 3:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
inputFieldName = args[2].ToString();
break;
default:
AAState.WriteLine(" ERROR: SIDE: Value info does not have enough parameters");
continue;
}
int fldValToCopyIdx = inObject.Fields.FindField(inputFieldName);
if (fldValToCopyIdx > -1)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
// Get layer
AAState.WriteLine(" " + sourceLayerName + " Layer found");
int fldValTargetJoinIdx = Globals.GetFieldIndex(sourceLayer, sourceFieldName);
if (fldValTargetJoinIdx > -1)
{
IQueryFilter pQFilt = Globals.createQueryFilter();
if (sourceLayer.FeatureClass.Fields.get_Field(fldValTargetJoinIdx).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + sourceLayer.FeatureClass.Fields.get_Field(fldValTargetJoinIdx).Name + "" + " = '" + inObject.get_Value(fldValToCopyIdx).ToString() + "'";
}
else
{
pQFilt.WhereClause = sourceLayer.FeatureClass.Fields.get_Field(fldValTargetJoinIdx).Name + " = " + inObject.get_Value(fldValToCopyIdx);
}
AAState.WriteLine(" Where Clause: " + pQFilt.WhereClause);
int cnt = sourceLayer.FeatureClass.FeatureCount(pQFilt);
AAState.WriteLine(" Feature Found: " + cnt);
if (cnt > 0)
{
fCursor = sourceLayer.FeatureClass.Search(pQFilt, true);
while ((sourceFeature = fCursor.NextFeature()) != null)
{
bool side = false;
if (Globals.GetPointOnLine(inFeature.Shape, sourceFeature.Shape, 450, out side) != null)
{
if (side)
{
AAState.WriteLine(" Right Side");
inFeature.set_Value(intFldIdxs[0], "Right");
}
else
{
AAState.WriteLine(" Left Side");
inFeature.set_Value(intFldIdxs[0], "Left");
}
if (fCursor != null)
Marshal.ReleaseComObject(fCursor);
fCursor = null;
continue;
}
}
if (fCursor != null)
Marshal.ReleaseComObject(fCursor);
fCursor = null;
}
pQFilt = null;
}
}
}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: SIDE" + Environment.NewLine + ex.Message);
}
finally
{
if (fCursor != null)
Marshal.ReleaseComObject(fCursor);
fCursor = null;
// pRowCh = null
AAState.WriteLine(" Finished: SIDE");
}
break;
}
case "PROMPT":
{
//Loop through all fields list in the fieldname
//If blank or null, prompt user for value
//Store Value
// IRowChanges pRowCh = null;
IDomain pDom = default(IDomain);
ISubtypes pSubType = null;
List<Globals.DomSubList> lst = null;
Globals.DomSubList dmRetVal = null;
// ICodedValueDomain pCV = null;
try
{
if ((inObject != null)) // (valData != null) &&
{
// pRowCh = inObject as IRowChanges;
//if (pRowCh.get_ValueChanged(intFldIdxs[0]) == false)
//{
// AAState.WriteLine(" PROMPT: Target value did not change, skipping");
// continue;
//}
//else
//{
pSubType = (ISubtypes)inObject.Class;
if (pSubType.HasSubtype)
{
int intSub;
if (intFldIdxs.Contains(pSubType.SubtypeFieldIndex))
{
lst = Globals.SubtypeToList(pSubType);
if (inObject.get_Value(pSubType.SubtypeFieldIndex) == null || inObject.get_Value(pSubType.SubtypeFieldIndex) == "" || inObject.get_Value(pSubType.SubtypeFieldIndex) == DBNull.Value)
{
dmRetVal = Globals.showValuesOptionsForm(lst, "Provide a value for " + inObject.Class.AliasName + ":" + pSubType.SubtypeFieldName, "Provide a value for " + inObject.Class.AliasName + ":" + pSubType.SubtypeFieldName, ComboBoxStyle.DropDownList);
inObject.set_Value(pSubType.SubtypeFieldIndex, dmRetVal.Value);
intSub = Convert.ToInt32(dmRetVal.Value);
}
else
{
intSub = Convert.ToInt32(inObject.get_Value(pSubType.SubtypeFieldIndex));
}
// intSub = (int)inObject.get_Value(pSubType.SubtypeFieldIndex);
for (int l = 0; l < strFldNames.Count; l++)
{
if (intFldIdxs[l] == pSubType.SubtypeFieldIndex)
continue;
if (intFldIdxs[l] != -1)
{
pDom = pSubType.get_Domain(intSub, inObject.Fields.get_Field(intFldIdxs[l]).Name);
//pDom = inObject.Fields.get_Field(intFldIdxs[l]).Domain;
if (pDom == null)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + inObject.Class.AliasName + ":" + strFldNames[l], "Provide a value for " + inObject.Class.AliasName + ":" + strFldNames[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
else
{
if (pDom is CodedValueDomain)
{
//pCV = default(ICodedValueDomain);
lst = Globals.DomainToList(pDom);
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
dmRetVal = Globals.showValuesOptionsForm(lst, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDownList);
try
{
inObject.set_Value(intFldIdxs[l], dmRetVal.Value);
}
catch
{
}
lst = null;
}
}
else
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
}
// IList<string> pVals = new List<string>();
// string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDown);
// inObject.set_Value(intFldIdxs[0], strRetVal);
}
else
{
AAState.WriteLine(" PROMPT: " + strFldNames[l] + " was not found");
}
}
}
else
{
if (inObject.get_Value(pSubType.SubtypeFieldIndex) == null)
intSub = pSubType.DefaultSubtypeCode;
else
intSub = Convert.ToInt32(inObject.get_Value(pSubType.SubtypeFieldIndex));
for (int l = 0; l < strFldNames.Count; l++)
{
if (intFldIdxs[l] != -1)
{
pDom = pSubType.get_Domain(intSub, inObject.Fields.get_Field(intFldIdxs[l]).Name);
//pDom = inObject.Fields.get_Field(intFldIdxs[l]).Domain;
if (pDom == null)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
else
{
if (pDom is CodedValueDomain)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
//pCV = default(ICodedValueDomain);
lst = Globals.DomainToList(pDom);
dmRetVal = Globals.showValuesOptionsForm(lst, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDownList);
try
{
inObject.set_Value(intFldIdxs[l], dmRetVal.Value);
}
catch
{
}
lst = null;
}
}
else
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
}
// IList<string> pVals = new List<string>();
// string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDown);
// inObject.set_Value(intFldIdxs[0], strRetVal);
}
else
{
AAState.WriteLine(" PROMPT: " + strFldNames[l] + " was not found");
}
}
}
}
else
{
for (int l = 0; l < strFldNames.Count; l++)
{
if (intFldIdxs[l] != -1)
{
pDom = inObject.Fields.get_Field(intFldIdxs[l]).Domain;
if (pDom == null)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
else
{
if (pDom is CodedValueDomain)
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
//pCV = default(ICodedValueDomain);
lst = Globals.DomainToList(pDom);
dmRetVal = Globals.showValuesOptionsForm(lst, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDownList);
try
{
inObject.set_Value(intFldIdxs[l], dmRetVal.Value);
}
catch
{
}
lst = null;
}
}
else
{
if (inObject.get_Value(intFldIdxs[l]) == null || inObject.get_Value(intFldIdxs[l]) == "" || inObject.get_Value(intFldIdxs[l]) == DBNull.Value)
{
IList<string> pVals = new List<string>();
string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDown);
try
{
inObject.set_Value(intFldIdxs[l], strRetVal);
}
catch
{
}
pVals = null;
}
}
}
// IList<string> pVals = new List<string>();
// string strRetVal = Globals.showValuesOptionsForm(pVals, "Provide a value for " + strFldNames[l], "Provide a value for " + strFldNames[l], ComboBoxStyle.DropDown);
// inObject.set_Value(intFldIdxs[0], strRetVal);
}
else
{
AAState.WriteLine(" PROMPT: " + strFldNames[l] + " was not found");
}
}
}
//}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: PROMPT" + Environment.NewLine + ex.Message);
}
finally
{
// pRowCh = null
AAState.WriteLine(" Finished: PROMPT");
pDom = null;
pSubType = null;
lst = null;
dmRetVal = null;
}
break;
}
//Not Used
case "VALIDATE_ATTRIBUTE_LOOKUP_old_NOT USED":
{
AAState.WriteLine(" Trying VALIDATE_ATTRIBUTE_LOOKUP");
IRowChanges pRowCh = null;
ISQLSyntax sqlSyntax = null;
IQueryFilter pQFilt = null;
try
{
if ((valData != null) && (inFeature != null))
{
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == false)
{
AAState.WriteLine(" VALIDATE_ATTRIBUTE_LOOKUP: Target value did not change, skipping");
continue;
}
sourceLayerName = "";
string[] sourceFieldNames = null;
//string[] destFieldNames = null;
// Parse arguments
args = valData.Split('|');
if (args.Length == 2)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
}
else
{
AAState.WriteLine(" ERROR: the valuemethod is not defined properly for this rule");
continue;
}
if ((sourceFieldNames != null) &&
(sourceFieldNames.Length > 0))
{
AAState.WriteLine(" Looking for layer: " + sourceLayerName);
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
}
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
sqlSyntax = (ISQLSyntax)(((IDataset)sourceLayer.FeatureClass).Workspace);
string specChar = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_WildcardManyMatch);
AAState.WriteLine(" Lookup layer " + sourceLayer.Name + " was Found: " + sourceLayerName);
string missingFieldMess = null;
int[] sourceFieldNums = new int[sourceFieldNames.Length];
AAState.WriteLine(" Checking for field in Lookup table");
int fnum = sourceLayer.FeatureClass.FindField(sourceFieldNames[0].Trim());
if (fnum < 0)
{
fnum = sourceLayer.FeatureClass.Fields.FindFieldByAliasName(sourceFieldNames[0].Trim());
}
if (fnum != -1)
{
AAState.WriteLine(" Field Found");
pQFilt = new QueryFilterClass();
if (inObject.get_Value(intFldIdxs[0]).ToString().Trim() == "")
{
if (mode == "ON_CREATE")
{
AAState.WriteLine(" Field Found");
continue;
}
pQFilt.WhereClause = "1=1";
}
else
{
if (sourceLayer.FeatureClass.Fields.get_Field(fnum).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + sourceLayer.FeatureClass.Fields.get_Field(fnum).Name + "" + " LIKE '" + specChar + inObject.get_Value(intFldIdxs[0]).ToString() + specChar + "'";
}
else
{
pQFilt.WhereClause = sourceLayer.FeatureClass.Fields.get_Field(fnum).Name + " LIKE " + specChar + inObject.get_Value(intFldIdxs[0]) + specChar;
}
}
AAState.WriteLine(" " + pQFilt.WhereClause + " used to search for matching record");
int intRecFound = sourceLayer.FeatureClass.FeatureCount(pQFilt);
AAState.WriteLine(" " + intRecFound + " rows found");
if (intRecFound != 1)
{
if (inObject.get_Value(intFldIdxs[0]).ToString().Trim() == "")
{
pQFilt.WhereClause = "1=1";
}
else
{
if (sourceLayer.FeatureClass.Fields.get_Field(fnum).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "UPPER(" + sourceLayer.FeatureClass.Fields.get_Field(fnum).Name + ")" + " LIKE '" + specChar + inObject.get_Value(intFldIdxs[0]).ToString().ToUpper() + specChar + "'";
}
else
{
pQFilt.WhereClause = sourceLayer.FeatureClass.Fields.get_Field(fnum).Name + " LIKE " + specChar + inObject.get_Value(intFldIdxs[0]) + specChar;
}
}
AAState.WriteLine(" " + pQFilt.WhereClause + " used to search for matching record");
intRecFound = sourceLayer.FeatureClass.FeatureCount(pQFilt);
AAState.WriteLine(" " + intRecFound + " rows found");
if (intRecFound == 0)
{
AAState.WriteLine(" Abort Edit");
AAState._editor.AbortOperation();
return false;
}
else
{
AAState.WriteLine(" Prompting for user input");
IFeatureCursor pFCurs = sourceLayer.FeatureClass.Search(pQFilt, true);
pQFilt = null;
ICursor pCurs = pFCurs as ICursor;
List<string> pLst = Globals.CursorToList(ref pCurs, fnum);
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
if (pFCurs != null)
Marshal.ReleaseComObject(pFCurs);
pFCurs = null;
string selectVal = Globals.showOptionsForm(pLst, "Select an value to store", ComboBoxStyle.DropDownList);
if (selectVal == "||Cancelled||")
{
AAState.WriteLine(" Abort Edit");
AAState._editor.AbortOperation();
return false;
}
else
{
AAState.WriteLine(" Value selected: " + selectVal);
inObject.set_Value(intFldIdxs[0], selectVal as object);
}
}
}
else
{
AAState.WriteLine(" One Exact match was found");
}
pQFilt = null;
}
else
{
AAState.WriteLine(" ERROR: Cant find field " + missingFieldMess);
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " data source is not set");
}
}
else
{
IStandaloneTable pTbl = Globals.FindStandAloneTable(AAState._editor.Map, sourceLayerName) as IStandaloneTable;
if (pTbl != null)
{
if (pTbl.Table != null)
{
sqlSyntax = (ISQLSyntax)(((IDataset)pTbl).Workspace);
string specChar = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_WildcardManyMatch);
AAState.WriteLine(" Lookup layer " + pTbl.Name + " was Found: " + sourceLayerName);
string missingFieldMess = null;
int[] sourceFieldNums = new int[sourceFieldNames.Length];
AAState.WriteLine(" Checking for field in Lookup table");
int fnum = pTbl.Table.FindField(sourceFieldNames[0].Trim());
if (fnum < 0)
{
fnum = pTbl.Table.Fields.FindFieldByAliasName(sourceFieldNames[0].Trim());
}
if (fnum != -1)
{
AAState.WriteLine(" Field Found");
pQFilt = new QueryFilterClass();
if (inObject.get_Value(intFldIdxs[0]).ToString().Trim() == "")
{
if (mode == "ON_CREATE")
{
AAState.WriteLine(" Empty Value on Create, skipping");
continue;
}
pQFilt.WhereClause = "1=1";
}
else
{
if (pTbl.Table.Fields.get_Field(fnum).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "" + pTbl.Table.Fields.get_Field(fnum).Name + "" + " LIKE '" + specChar + inObject.get_Value(intFldIdxs[0]).ToString() + specChar + "'";
}
else
{
pQFilt.WhereClause = pTbl.Table.Fields.get_Field(fnum).Name + " LIKE " + specChar + inObject.get_Value(intFldIdxs[0]) + specChar;
}
}
AAState.WriteLine(" " + pQFilt.WhereClause + " used to search for matching record");
int intRecFound = pTbl.Table.RowCount(pQFilt);
AAState.WriteLine(" " + intRecFound + " rows found");
if (intRecFound != 1)
{
if (inObject.get_Value(intFldIdxs[0]).ToString().Trim() == "")
{
pQFilt.WhereClause = "1=1";
}
else
{
if (pTbl.Table.Fields.get_Field(fnum).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = "UPPER(" + pTbl.Table.Fields.get_Field(fnum).Name + ")" + " LIKE '" + specChar + inObject.get_Value(intFldIdxs[0]).ToString().ToUpper() + specChar + "'";
}
else
{
pQFilt.WhereClause = pTbl.Table.Fields.get_Field(fnum).Name + " LIKE " + specChar + inObject.get_Value(intFldIdxs[0]) + specChar;
}
}
AAState.WriteLine(" " + pQFilt.WhereClause + " used to search for matching record");
intRecFound = pTbl.Table.RowCount(pQFilt);
AAState.WriteLine(" " + intRecFound + " rows found");
if (intRecFound == 0)
{
AAState.WriteLine(" Abort Edit");
AAState._editor.AbortOperation();
return false;
}
else
{
AAState.WriteLine(" Prompting for user input");
ICursor pCurs = pTbl.Table.Search(pQFilt, true);
List<string> pLst = Globals.CursorToList(ref pCurs, fnum);
if (pCurs != null)
Marshal.ReleaseComObject(pCurs);
pCurs = null;
string selectVal = Globals.showOptionsForm(pLst, "Select an value to store", ComboBoxStyle.DropDownList);
if (selectVal == "||Cancelled||")
{
AAState.WriteLine(" Abort Edit");
AAState._editor.AbortOperation();
return false;
}
else
{
AAState.WriteLine(" Value selected: " + selectVal);
inObject.set_Value(intFldIdxs[0], selectVal as object);
}
//AAState.WriteLine(" Value selected: " + selectVal);
//inObject.set_Value(intFldIdxs[0], selectVal as object);
}
}
else
{
AAState.WriteLine(" One Exact match was found");
}
pQFilt = null;
}
else
{
AAState.WriteLine(" ERROR: Cant find field " + missingFieldMess);
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " data source is not set");
}
pTbl = null;
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " was not found");
}
}
}
else
{
AAState.WriteLine(" ERROR: Invalid Value Info: " + valData);
}
}
else
{
AAState.WriteLine(" ERROR: Not a feature or missing Value Info");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: VALIDATE_ATTRIBUTE_LOOKUP" + Environment.NewLine + ex.Message);
}
finally
{
pQFilt = null;
sqlSyntax = null;
pRowCh = null;
AAState.WriteLine(" Finished: VALIDATE_ATTRIBUTE_LOOKUP");
}
break;
}
case "CASCADE_ATTRIBUTE":
{
AAState.WriteLine(" Trying: CASCADE_ATTRIBUTE");
string flds;
string targetLayer;
IRowChanges pRowCh = null;
//IFeature pNewFeat = null;
try
{
if ((valData != null) && (inObject != null))
{
AAState.WriteLine(" Feature and valueinfo is valid");
AAState.WriteLine(" Splitting up value info: " + valData);
//field name is the field to Check
//value|Layer|tempalte|Cut or Copy|field-toField
args = valData.Split('|');
if (args.Length < 2)
{
AAState.WriteLine(" ERROR: CASCADE_ATTRIBUTE: Value info does not have enough parameters");
continue;
}
targetLayer = args[0];
flds = args[1];
bool bPrompt;
if (args.Length == 3)
{
if (args[2].ToUpper() == "T" || args[2].ToUpper() == "TRUE" || args[2].ToUpper() == "YES")
{
bPrompt = true;
}
else
{
bPrompt = false;
}
}
else
{
bPrompt = true;
}
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == false)
{
AAState.WriteLine(" CASCADE_ATTRIBUTE: Target value did not change, skipping");
continue;
}
bool boolFoundAsLayer = true;
sourceLayer = Globals.FindLayer(ArcMap.Application, args[0].ToString(), ref boolFoundAsLayer) as IFeatureLayer;
if (sourceLayer == null)
{
AAState.WriteLine(" ERROR: CASCADE_ATTRIBUTE: Target layer was not found");
continue;
}
int intTargFld = -1;
intTargFld = sourceLayer.FeatureClass.Fields.FindField(flds);
if (intTargFld == -1)
{
intTargFld = sourceLayer.FeatureClass.Fields.FindFieldByAliasName(flds);
if (intTargFld != -1)
{
flds = sourceLayer.FeatureClass.Fields.get_Field(intTargFld).Name;
}
}
if (intTargFld > -1)
{
if (pRowCh.get_OriginalValue(intFldIdxs[0]).ToString().Trim() == "")
continue;
IQueryFilter pQFilt = new QueryFilterClass();
if (sourceLayer.FeatureClass.Fields.get_Field(intTargFld).Type == esriFieldType.esriFieldTypeString)
{
pQFilt.WhereClause = flds + " = '" + pRowCh.get_OriginalValue(intFldIdxs[0]) + "'";
}
else
{
pQFilt.WhereClause = flds + " = " + pRowCh.get_OriginalValue(intFldIdxs[0]) + "";
}
int featCnt = sourceLayer.FeatureClass.FeatureCount(pQFilt);
if (featCnt == 0)
{
AAState.WriteLine(" Skipping, no Matching records found");
}
else
{
string promptLayname;
//if (boolFoundAsLayer)
//{
// promptLayname = sourceLayer.Name;
//}
//else
//{
promptLayname = Globals.getClassName(sourceLayer);
//}
if (bPrompt)
{
if (MessageBox.Show("You are about to change " + featCnt + " rows in the " + promptLayname + " Feature Class, proceed?", "Cascade", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
AAState.WriteLine(" User accepted prompt");
}
else
{
AAState.WriteLine(" User declined prompt");
}
}
else
{
AAState.WriteLine(" Prompt surpressed");
}
}
IFeatureCursor pCalcCursor = sourceLayer.FeatureClass.Update(pQFilt, false);
IFeature updateFeat;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
while ((updateFeat = pCalcCursor.NextFeature()) != null)
{
updateFeat.set_Value(intTargFld, inObject.get_Value(intFldIdxs[0]));
ChangeFeatureList.Add(updateFeat);
}
updateFeat = null;
//ICalculator pCalc = new CalculatorClass();
// pCalc.Cursor = pCalcCursor as ICursor;
// //pCalc.PreExpression = "Dim OldValue As String" + Environment.NewLine +
// // "OldValue = Trim ( [" + flds + "])" + Environment.NewLine +
// // "Dim newValue As String" + Environment.NewLine +
// // "newValue = " + pRowCh.get_ValueChanged(intFldIdxs[0]);
// if (sourceLayer.FeatureClass.Fields.get_Field(intTargFld).Type == esriFieldType.esriFieldTypeString)
// {
// pCalc.PreExpression = "Dim newValue" + Environment.NewLine +
// "newValue = \"" + inObject.get_Value(intFldIdxs[0]).ToString() + "\"";
// }
// else
// {
// pCalc.PreExpression = "Dim newValue" + Environment.NewLine +
// "newValue = " + inObject.get_Value(intFldIdxs[0]).ToString() ;
// }
// pCalc.Expression = "newValue";
//// pCalc.Expression = inObject.get_Value(intFldIdxs[0]).ToString();
// pCalc.Field = flds;
// pCalc.ShowErrorPrompt = true;
// pCalc.Calculate();
// if (pCalcCursor != null)
// {
// Marshal.ReleaseComObject(pCalcCursor);
// }
// pCalc = null;
if (pCalcCursor != null)
{
Marshal.ReleaseComObject(pCalcCursor);
}
pCalcCursor = null;
pQFilt = null;
}
else
{
AAState.WriteLine(" ERROR: CASCADE_ATTRIBUTE: Field was not found");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: CASCADE_ATTRIBUTE" + Environment.NewLine + ex.Message);
}
finally
{
sourceLayer = null;
pRowCh = null;
// pNewFeat = null;
AAState.WriteLine(" Finished: CASCADE_ATTRIBUTE");
}
break;
}
case "COPY_FEATURE":
{
AAState.WriteLine(" Trying: COPY_FEATURE");
IFeatureLayer pTargetFL;
string[] FldPairs;
string targetValue;
IRowChanges pRowCh = null;
IFeature pNewFeat = null;
try
{
if ((valData != null) && (inFeature != null))
{
AAState.WriteLine(" Feature and valueinfo is valid");
AAState.WriteLine(" Splitting up value info: " + valData);
//field name is the field to Check
//value|Layer|tempalte|Cut or Copy|field-toField
args = valData.Split('|');
if (args.Length < 2)
{
AAState.WriteLine(" ERROR: COPY_FEATURE: Value info does not have enough parameters");
continue;
}
targetValue = args[0];
pRowCh = inObject as IRowChanges;
if (pRowCh.get_ValueChanged(intFldIdxs[0]) == false)
{
AAState.WriteLine(" COPY_FEATURE: Field listed in the Field Name did not change, skipping");
continue;
}
if (inFeature.get_Value(intFldIdxs[0]).ToString() != targetValue.ToString())
{
AAState.WriteLine(" COPY_FEATURE: Target value did not match listed value, skipping");
continue;
}
//changed = true;
bool FCorLayerTarget = true;
pTargetFL = Globals.FindLayer(ArcMap.Application, args[1].ToString(), ref FCorLayerTarget) as IFeatureLayer;
if (pTargetFL == null)
{
AAState.WriteLine(" ERROR: COPY_FEATURE: Target layer was not found");
continue;
}
if (Globals.IsEditable(ref pTargetFL, ref AAState._editor) == false)
{
AAState.WriteLine(" ERROR: COPY_FEATURE: Target layer is not editable");
continue;
}
if (pTargetFL.FeatureClass.ShapeType != (inFeature.Class as IFeatureClass).ShapeType)
{
AAState.WriteLine(" ERROR: COPY_FEATURE: Target layer and Source layer are different geometry types");
continue;
}
FldPairs = null;
//value|Layer|tempalte|Cut or Copy|field-toField
IEditTemplate pEditTemp = null;
string sourceAction = "COPY";
string fldMatching = null;
switch (args.Length)
{
//case 2:
// break;
case 3:
if (args[2].Trim() != "")
{
//pEditTemp = Globals.PromptAndGetEditTemplate(ArcMap.Application, pTargetFL, args[2].Trim());
pEditTemp = Globals.PromptAndGetEditTemplateGraphic(pTargetFL, args[2].Trim());
}
else
{
pEditTemp = null;
}
break;
case 4:
if (args[2].Trim() != "")
{
//pEditTemp = Globals.PromptAndGetEditTemplate(ArcMap.Application, pTargetFL, args[2].Trim());
pEditTemp = Globals.PromptAndGetEditTemplateGraphic(pTargetFL, args[2].Trim());
}
else
{
pEditTemp = null;
}
sourceAction = args[3].ToUpper().Trim();
//fldMatching = args[4].Trim();
break;
case 5:
if (args[2].Trim() != "")
{
//pEditTemp = Globals.PromptAndGetEditTemplate(ArcMap.Application, pTargetFL, args[2].Trim());
pEditTemp = Globals.PromptAndGetEditTemplateGraphic(pTargetFL, args[2].Trim());
}
else
{
pEditTemp = null;
}
sourceAction = args[3].ToUpper().Trim();
fldMatching = args[4].Trim();
break;
}
if (pEditTemp != null)
{
pNewFeat = Globals.CreateFeature(inFeature.ShapeCopy, pEditTemp, AAState._editor, ArcMap.Application, false, false, false);
}
else
{
pNewFeat = Globals.CreateFeature(inFeature.ShapeCopy, pTargetFL, AAState._editor, ArcMap.Application, false, false, false);
}
pEditTemp = null;
if (fldMatching != null)
{
if (fldMatching == "")
{
FldPairs = new string[] { };
}
else
{
FldPairs = fldMatching.Split(',');
}
}
else
{
FldPairs = new string[] { };
}
//pNewFeat = pTargetFL.FeatureClass.CreateFeature();
//pNewFeat.Shape = inFeature.Shape;
List<string> targFilds = new List<string>();
foreach (string strFlpPair in FldPairs)
{
string[] fldMatch = strFlpPair.Split('-');
if (fldMatch.Length != 2)
{
AAState.WriteLine(" ERROR: COPY_FEATURE: Field pairing is not properly defined");
}
else
{
string strSrcFldName = fldMatch[0];
string strTarFldName = fldMatch[1];
int intSrcFldIdx = Globals.GetFieldIndex((inFeature.Class as IFeatureClass).Fields, (strSrcFldName));
int intTarFldIdx = Globals.GetFieldIndex(pTargetFL.FeatureClass.Fields, strTarFldName);
if (intSrcFldIdx == -1 || intTarFldIdx == -1)
{
AAState.WriteLine(" ERROR: COPY_FEATURE: Either the source or target field was not found");
}
else
{
targFilds.Add(strTarFldName.ToUpper());
try
{
pNewFeat.set_Value(intTarFldIdx, inFeature.get_Value(intSrcFldIdx));
}
catch
{
AAState.WriteLine(" ERROR: COPY_FEATURE: Setting value: " + strFlpPair);
}
}
}
}
IFields pTarFields = pTargetFL.FeatureClass.Fields;
IField pTarField = null;
for (int i = 0; i < pTarFields.FieldCount; i++)
{
pTarField = pTarFields.get_Field(i);
if (pTarField.Type != esriFieldType.esriFieldTypeGlobalID &&
pTarField.Type != esriFieldType.esriFieldTypeOID &&
pTarField.Type != esriFieldType.esriFieldTypeGeometry &&
pTarField.Name.ToUpper() != "SHAPE_LENGTH" &&
pTarField.Name.ToUpper() != "SHAPE.LEN" &&
pTarField.Name.ToUpper() != "SHAPE_AREA" &&
pTarField.Name.ToUpper() != "SHAPE.AREA")
{
if (targFilds.Contains(pTarField.Name.ToUpper()) == false)
{
int fldIdx = inFeature.Fields.FindField(pTarField.Name);
if (fldIdx > 0)
{
try
{
pNewFeat.set_Value(i, inFeature.get_Value(fldIdx));
}
catch
{
AAState.WriteLine(" WARNING: COPY_FEATURE: Setting value: " + pTarField.Name);
}
}
}
}
}
pTarFields = null;
pTarField = null;
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//pNewFeat.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
NewFeatureList.Add(pNewFeat);
if (sourceAction == "CUT")
{
MessageBox.Show("CUT is not supported at the moment");
}
}
else
{
AAState.WriteLine(" ERROR: Value info was not correct");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: COPY_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
pTargetFL = null;
pRowCh = null;
pNewFeat = null;
AAState.WriteLine(" Finished: COPY_FEATURE");
}
break;
}
case "VALIDATE_CONNECTIVITY":
{
AAState.WriteLine(" Trying: VALIDATE_CONNECTIVITY");
try
{
// if (netFeat != null)
//IRowChanges pRowCh = inObject as IRowChanges;
//changed = true;
//if (mode != "ON_CREATE")
//{
//}
if ((valData != null) && (inFeature != null))
{
AAState.WriteLine(" Feature and valueinfo is valid");
AAState.WriteLine(" Checking if feature is in a geometric network");
bool validFeat = false;
if (inFeature is INetworkFeature)
{
AAState.WriteLine(" Feature is in a geometric network");
AAState.WriteLine(" Splitting up value info: " + valData);
args = valData.Split('|');
int connectionCnt = Globals.getConnectionCount(inFeature);
foreach (string fldConPair in args)
{
string[] fldCon = fldConPair.Split(',');
if (fldCon.Length == 1)
{
AAState.WriteLine(" No values for the specified fields");
if (Globals.IsNumeric(fldCon[0]))
{
if (connectionCnt == Convert.ToInt32(fldCon[0]))
{
AAState.WriteLine(" Valid Connection Rule Found");
validFeat = true;
break;
}
}
else
{
AAState.WriteLine(" ERROR: Connection value is not numeric");
}
}
else
{
if (intFldIdxs.Count == 0)
{
AAState.WriteLine(" No values for the specified fields");
if (fldCon.Length == 2)
{
if (connectionCnt == Convert.ToInt32(fldCon[1]))
{
AAState.WriteLine(" Valid Connection Rule Found");
validFeat = true;
break;
}
}
if (fldCon.Length > 2)
{
if (connectionCnt >= Convert.ToInt32(fldCon[1]) && connectionCnt <= Convert.ToInt32(fldCon[2]))
{
AAState.WriteLine(" Valid Connection Rule Found");
validFeat = true;
break;
}
}
}
else if (inFeature.get_Value(intFldIdxs[0]).ToString() == fldCon[0])
{
if (fldCon.Length == 2)
{
if (connectionCnt == Convert.ToInt32(fldCon[1]))
{
AAState.WriteLine(" Valid Connection Rule Found");
validFeat = true;
break;
}
}
if (fldCon.Length > 2)
{
if (connectionCnt >= Convert.ToInt32(fldCon[1]) && connectionCnt <= Convert.ToInt32(fldCon[2]))
{
AAState.WriteLine(" Valid Connection Rule Found");
validFeat = true;
break;
}
}
//iSJunc.EdgeFeatureCount <= 1
}
}
}
if (validFeat == false)
{
AAState.WriteLine(" Abort Edit");
AAState._editor.AbortOperation();
return false;
}
}
else
{
AAState.WriteLine(" ERROR: Feature is not a geometric network feature");
}
}
else
{
AAState.WriteLine(" ERROR: Value info was not correct");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: VALIDATE_CONNECTIVITY" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: VALIDATE_CONNECTIVITY");
}
break;
}
case "VALIDATE_ATTRIBUTES":
{
AAState.WriteLine(" Trying: VALIDATE_ATTRIBUTES");
try
{
if ((valData != null) && (inFeature != null))
{
AAState.WriteLine(" Feature and valueinfo is valid");
IRowChanges pRowCh = inObject as IRowChanges;
changed = true;
if (intFldIdxs != null && intFldIdxs.Count > 0 && mode != "ON_CREATE")
{
for (int fldIdx = 0; fldIdx < intFldIdxs.Count; fldIdx++)
{
AAState.WriteLine(" Row to monitor specified");
changed = pRowCh.get_ValueChanged(intFldIdxs[fldIdx]);
AAState.WriteLine(" " + strFldNames[fldIdx] + " changed value was " + changed);
if (changed)
break;
}
}
if (changed)
{
args = valData.Split('|');
args = args[0].Split(',');
AAState.WriteLine(" Checking fields to compare: " + args);
if (args.Length > 0)
{
// IList<string> pFldsToEval = new List<String>(args);
//pFldsToEval = args.ToList();
AAState.WriteLine(" Getting templates for feature class");
IList<ILayer> pLayList = Globals.FindLayersByClassID(((IMxDocument)ArcMap.Application.Document).FocusMap, inObject.Class.ObjectClassID);
if (pLayList != null)
{
if (pLayList.Count > 0)
{
AAState.WriteLine(" " + pLayList.Count + " Layers found");
bool ValidComb = false;
foreach (ILayer pLay in pLayList)
{
AAState.WriteLine(" Checking " + pLay.Name);
if (pLay is IFeatureLayer)
{
AAState.WriteLine(" Layer is a featurelayer");
// IList<string> pEditTemplateNames = Globals.GetEditTemplateNames(ArcMap.Application, (IFeatureLayer)pLay);
//IList<IEditTemplate> pEditTemplates = Globals.GetEditTemplates(ArcMap.Application, (IFeatureLayer)pLay);
//foreach (string IEditTemplate in pEditTemplates)
//{
//Globals.GetEditTemplate(pEditTemplateName,
//}
AAState.WriteLine(" Getting Edit Template Manager");
IEditTemplateManager pEdTmpManager = Globals.GetEditTemplateManager((IFeatureLayer)pLay);
AAState.WriteLine(" Checking templates");
ValidComb = Globals.FeatureIsValidTemplate(pEdTmpManager, inFeature, args);
AAState.WriteLine(" Template Found Status: " + ValidComb.ToString());
if (ValidComb == true)
break;
}
}
if (ValidComb == false)
{
AAState.WriteLine(" Abort Edit");
AAState._editor.AbortOperation();
return false;
}
}
else
{
AAState.WriteLine(" WARNING: No layers where found!");
}
}
else
{
AAState.WriteLine(" WARNING: No layers where found!");
}
}
}
else
{
AAState.WriteLine(" Monitored fields where not changed");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: VALIDATE_ATTRIBUTES" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: VALIDATE_ATTRIBUTES");
}
break;
}
//case "SPLIT_INTERSECTING_FEATURE":
// {
// AAState.WriteLine(" Trying: SPLIT_INTERSECTING_FEATURE");
// try
// {
// if ((valData != null) && (inFeature != null))
// {
// intersectLayerName = "";
// intersectLayer = null;
// args = valData.Split('|');
// if (args.Length > 0)
// {
// AAState.WriteLine(" " + args.Length + " Layers listed ");
// for (int i = 0; i < args.Length; i++)
// {
// intersectLayerName = args[i].Trim();
// AAState.WriteLine(" Searching for " + intersectLayerName);
// boolLayerOrFC = true;
// if (intersectLayerName.Contains("("))
// {
// string[] tempSplt = intersectLayerName.Split('(');
// intersectLayerName = tempSplt[0];
// intersectLayer = Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC) as IFeatureLayer;
// if (tempSplt[1].ToUpper().Contains("LAYER)"))
// {
// boolLayerOrFC = true;
// }
// else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
// {
// boolLayerOrFC = true;
// }
// else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
// {
// boolLayerOrFC = false;
// }
// else if (tempSplt[1].ToUpper().Contains("CLASS)"))
// {
// boolLayerOrFC = false;
// }
// else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
// {
// boolLayerOrFC = false;
// }
// else
// {
// boolLayerOrFC = true;
// }
// }
// else
// {
// intersectLayer = Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC) as IFeatureLayer;
// }
// if (intersectLayer != null)
// {
// AAState.WriteLine(" Layer Found " + intersectLayerName);
// if (intersectLayer.FeatureClass != null)
// {
// AAState.WriteLine(" Datasource is valid for " + intersectLayerName);
// // sFilter = new SpatialFilterClass();
// sFilter = Globals.createSpatialFilter(intersectLayer, inFeature, false);
// AAState.WriteLine(" Checking source Geometry Type");
// AAState.WriteLine(" Searching " + intersectLayerName + "for intersected feature");
// //if (boolLayerOrFC)
// //{
// // fCursor = intersectLayer.Search(sFilter, true);
// //}
// //else
// //{
// // fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
// //}
// pFS = (IFeatureSelection)intersectLayer;
// if (boolLayerOrFC)
// {
// if (pFS.SelectionSet.Count > 0)
// {
// pFS.SelectionSet.Search(sFilter, true, out cCurs);
// fCursor = cCurs as IFeatureCursor;
// }
// else
// {
// fCursor = intersectLayer.Search(sFilter, true);
// }
// }
// else
// {
// fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
// }
// IFeature intsersectFeature;
// int idx = 1;
// while ((intsersectFeature = fCursor.NextFeature()) != null)
// {
// if (intsersectFeature.Class != inFeature.Class)
// {
// AAState.WriteLine(" Splitting Intersected Feature number: " + idx);
// idx++;
// IFeatureEdit2 featureEdit = intsersectFeature as IFeatureEdit2;
// ISet featset = featureEdit.SplitWithUpdate(inFeature.Shape);
// AAState.WriteLine(" Adding split features to array to call the AA ext");
// if (featset.Count > 0)
// {
// if (NewFeatureList == null)
// {
// NewFeatureList = new List<IObject>();
// }
// object featobj;
// while ((featobj = featset.Next()) != null)
// {
// IFeature feature = featobj as IFeature;
// //feature.Store();
// if (feature != null)
// {
// NewFeatureList.Add(feature as IObject);
// }
// feature = null;
// }
// }
// AAState.WriteLine(" Split feature " + intersectLayerName + " into " + featset.Count);
// if (intsersectFeature != null)
// {
// Marshal.ReleaseComObject(intsersectFeature);
// }
// featureEdit = null;
// featset = null;
// }
// else if (intsersectFeature.Class == inFeature.Class && intsersectFeature.OID != inFeature.OID)
// {
// AAState.WriteLine(" Splitting Intersected Feature number: " + idx);
// idx++;
// IFeatureEdit2 featureEdit = intsersectFeature as IFeatureEdit2;
// ISet featset = featureEdit.SplitWithUpdate(inFeature.Shape);
// AAState.WriteLine(" Adding split features to array to call the AA ext");
// if (featset.Count > 0)
// {
// if (NewFeatureList == null)
// {
// NewFeatureList = new List<IObject>();
// }
// object featobj;
// while ((featobj = featset.Next()) != null)
// {
// IFeature feature = featobj as IFeature;
// if (feature != null)
// {
// NewFeatureList.Add(feature as IObject);
// }
// feature = null;
// // feature.Store();
// }
// }
// AAState.WriteLine(" Split feature " + intersectLayerName + " into " + featset.Count);
// if (intsersectFeature != null)
// {
// Marshal.ReleaseComObject(intsersectFeature);
// }
// featureEdit = null;
// featset = null;
// }
// }
// intsersectFeature = null;
// }
// }
// else
// {
// AAState.WriteLine(" Warning: Can't find intersecting layer: " + intersectLayerName);
// }
// }
// }
// else
// {
// AAState.WriteLine(" ERROR: Unsupported Value Info: " + valData);
// }
// }
// else
// {
// AAState.WriteLine(" ERROR: not a feature or no Value Info");
// }
// }
// catch (Exception ex)
// {
// AAState.WriteLine(" ERROR: SPLIT_INTERSECTING_FEATURE" + Environment.NewLine + ex.Message);
// }
// finally
// {
// AAState.WriteLine(" Finished: SPLIT_INTERSECTING_FEATURE");
// }
// break;
// }
case "SPLIT_INTERSECTING_FEATURE":
{
AAState.WriteLine(" Trying: SPLIT_INTERSECTING_FEATURE");
try
{
if ((valData != null) && (inFeature != null))
{
intersectLayerName = "";
intersectLayer = null;
args = valData.Split('|');
if (args.Length > 0)
{
AAState.WriteLine(" " + args.Length + " Layers listed ");
for (int i = 0; i < args.Length; i++)
{
intersectLayerName = args[i].Trim();
AAState.WriteLine(" Searching for " + intersectLayerName);
boolLayerOrFC = true;
if (intersectLayerName.Contains("("))
{
string[] tempSplt = intersectLayerName.Split('(');
intersectLayerName = tempSplt[0];
intersectLayer = Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC) as IFeatureLayer;
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
intersectLayer = Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC) as IFeatureLayer;
}
if (intersectLayer != null)
{
AAState.WriteLine(" Layer Found " + intersectLayerName);
if (intersectLayer.FeatureClass != null)
{
AAState.WriteLine(" Datasource is valid for " + intersectLayerName);
double snapTol = Globals.GetXYTolerance(intersectLayer);
// sFilter = new SpatialFilterClass();
sFilter = Globals.createSpatialFilter(intersectLayer, inFeature, false);
AAState.WriteLine(" Checking source Geometry Type");
AAState.WriteLine(" Searching " + intersectLayerName + "for intersected feature");
//if (boolLayerOrFC)
//{
// fCursor = intersectLayer.Search(sFilter, true);
//}
//else
//{
// fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
//}
pFS = (IFeatureSelection)intersectLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = intersectLayer.Search(sFilter, true);
}
}
else
{
fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
}
IFeature intsersectFeature;
int idx = 1;
while ((intsersectFeature = fCursor.NextFeature()) != null)
{
if (intsersectFeature.Class != inFeature.Class)
{
AAState.WriteLine(" Splitting Intersected Feature number: " + idx);
idx++;
// IFeatureEdit2 featureEdit = intsersectFeature as IFeatureEdit2;
//ISet featset = featureEdit.SplitWithUpdate(inFeature.ShapeCopy);
if (intsersectFeature is INetworkFeature)
{
AAState.WriteLine(" Line to split is a Geometric Network line, this operation is not valid for these types of features");
}
else
{
ISet featset = Globals.splitLineWithPoint(intsersectFeature, inFeature.ShapeCopy as IPoint, snapTol, null, "{0:0.00}", ArcMap.Application);
if (featset != null)
{
AAState.WriteLine(" Adding split features to array to call the AA ext");
if (featset.Count > 0)
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
object featobj;
while ((featobj = featset.Next()) != null)
{
IFeature feature = featobj as IFeature;
//feature.Store();
if (feature != null)
{
NewFeatureList.Add(feature as IObject);
}
feature = null;
}
}
AAState.WriteLine(" Split feature " + intersectLayerName + " into " + featset.Count);
}
else
{
AAState.WriteLine(" Split return no features");
}
featset = null;
}
}
if (intsersectFeature != null)
{
Marshal.ReleaseComObject(intsersectFeature);
}
//featureEdit = null;
else if (intsersectFeature.Class == inFeature.Class && intsersectFeature.OID != inFeature.OID)
{
AAState.WriteLine(" Splitting Intersected Feature number: " + idx);
idx++;
if (intsersectFeature is INetworkFeature)
{
AAState.WriteLine(" Line to split is a Geometric Network line, this operation is not valid for these types of features");
}
else
{
// IFeatureEdit2 featureEdit = intsersectFeature as IFeatureEdit2;
//ISet featset = featureEdit.SplitWithUpdate(inFeature.Shape);
ISet featset = Globals.splitLineWithPoint(intsersectFeature, inFeature.ShapeCopy as IPoint, snapTol, null, "{0:0.00}", ArcMap.Application);
if (featset == null)
{
AAState.WriteLine(" Error splitting feature, the feature may be a geometric network feature");
}
else
{
AAState.WriteLine(" Adding split features to array to call the AA ext");
if (featset.Count > 0)
{
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
object featobj;
while ((featobj = featset.Next()) != null)
{
IFeature feature = featobj as IFeature;
if (feature != null)
{
NewFeatureList.Add(feature as IObject);
}
feature = null;
// feature.Store();
}
}
AAState.WriteLine(" Split feature " + intersectLayerName + " into " + featset.Count);
}
featset = null;
}
if (intsersectFeature != null)
{
Marshal.ReleaseComObject(intsersectFeature);
}
}
}
intsersectFeature = null;
}
}
else
{
AAState.WriteLine(" Warning: Can't find intersecting layer: " + intersectLayerName);
}
}
}
else
{
AAState.WriteLine(" ERROR: Unsupported Value Info: " + valData);
}
}
else
{
AAState.WriteLine(" ERROR: not a feature or no Value Info");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: SPLIT_INTERSECTING_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: SPLIT_INTERSECTING_FEATURE");
}
break;
}
case "NEAREST_FEATURE_ATTRIBUTES":
{
AAState.WriteLine(" Trying NEAREST_FEATURE_ATTRIBUTES");
try
{
if ((valData != null) && (inFeature != null))
{
sourceLayerName = "";
string[] sourceFieldNames = null;
string[] destFieldNames = null;
searchDistance = 0;
// Parse arguments
args = valData.Split('|');
if (args.Length == 3)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
destFieldNames = args[2].ToString().Split(',');
AAState.WriteLine(" WARNING: search distance as not specified, defaulting to 0");
}
else if (args.Length == 4)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
destFieldNames = args[2].ToString().Split(',');
Double.TryParse(args[3], out searchDistance);
}
else
{
AAState.WriteLine(" ERROR: the valuemethod is not defined properly for this rule");
continue;
}
if ((sourceFieldNames != null) && (destFieldNames != null) &&
(sourceFieldNames.Length > 0) && (destFieldNames.Length > 0) &&
(sourceFieldNames.Length == destFieldNames.Length))
{
AAState.WriteLine(" Looking for layer: " + sourceLayerName);
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC) as IFeatureLayer;
}
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
AAState.WriteLine(" " + sourceLayer.Name + " layer Found: " + sourceLayerName);
string missingFieldMess = null;
int[] sourceFieldNums = new int[sourceFieldNames.Length];
int[] destFieldNums = new int[destFieldNames.Length];
AAState.WriteLine(" Checking Field Mapping");
for (int i = 0; i < sourceFieldNums.Length; i++)
{
int fnum = sourceLayer.FeatureClass.FindField(sourceFieldNames[i].Trim());
if (fnum < 0)
{
missingFieldMess = sourceFieldNames[i].Trim() + " in table " + sourceLayerName;
break;
}
sourceFieldNums[i] = fnum;
}
if (missingFieldMess == null)
{
for (int i = 0; i < destFieldNums.Length; i++)
{
int fnum = inFeature.Fields.FindField(destFieldNames[i].Trim());
if (fnum < 0)
{
missingFieldMess = destFieldNames[i].Trim() + " in table " + tableName;
break;
}
destFieldNums[i] = fnum;
}
}
if (missingFieldMess == null)
{
AAState.WriteLine(" Field Mapping verified");
// found source and destination fields.
//sFilter = new SpatialFilterClass();
if (searchDistance > 0)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
//searchEnvelope = inFeature.ShapeCopy.Envelope;
//searchEnvelope.Expand(searchDistance, searchDistance, false);
//sFilter.Geometry = searchEnvelope;
}
else
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
//sFilter.Geometry = inFeature.ShapeCopy;
}
// sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
// sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
AAState.WriteLine(" Searching for Nearest Feature");
//if (boolLayerOrFC)
//{
// fCursor = sourceLayer.Search(sFilter, false);
//}
//else
//{
// fCursor = sourceLayer.FeatureClass.Search(sFilter, false);
//}
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, false, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, false);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, false);
}
sourceFeature = fCursor.NextFeature();
nearestFeature = null;
proxOp = (IProximityOperator)inFeature.Shape;
lastDistance = searchDistance;
if (sourceFeature != null)
{
AAState.WriteLine(" Features Found, looping for closest");
while (sourceFeature != null)
{
if (sourceFeature.Class != inFeature.Class)
{
//distance = proxOp.ReturnDistance(sourceFeature.Shape);
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
//distance = proxOp.ReturnDistance(sourceFeature.Shape);
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
sourceFeature = fCursor.NextFeature();
}
}
if (nearestFeature != null)
{
AAState.WriteLine(" Closest Feature is " + lastDistance + " Away with OID of " + nearestFeature.OID);
for (int i = 0; i < sourceFieldNums.Length; i++)
{
try
{
AAState.WriteLine(" Trying to copy " + sourceFieldNames[i] + " to " + destFieldNames[i]);
inObject.set_Value(destFieldNums[i], nearestFeature.get_Value(sourceFieldNums[i]));
}
catch
{
AAState.WriteLine(" ERROR: copying " + sourceFieldNames[i] + " to " + destFieldNames[i]);
}
}
}
else
{
AAState.WriteLine(" No Feature was found, default fields");
for (int i = 0; i < destFieldNums.Length; i++)
{
IField field = inObject.Fields.get_Field(destFieldNums[i]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(destFieldNums[i], null);
}
}
else
{
inObject.set_Value(destFieldNums[i], newval);
}
}
}
}
else
{
AAState.WriteLine(" ERROR: Cant find field " + missingFieldMess);
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " data source is not set");
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayerName + " was not found");
}
}
else
{
AAState.WriteLine(" ERROR: Invalid Value Info: " + valData);
}
}
else
{
AAState.WriteLine(" ERROR: Not a feature or missing Value Info");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: NEAREST_FEATURE_ATTRIBUTES" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: NEAREST_FEATURE_ATTRIBUTES");
}
break;
}
case "MINIMUM_LENGTH":
{
try
{
AAState.WriteLine(" Trying MINIMUM_LENGTH");
double minlength;
AAState.WriteLine(" Evaluating Minimum length value");
if (Double.TryParse(valData, out minlength))
{
if (inFeature != null)
{
ICurve curve = inFeature.Shape as ICurve;
if (curve != null)
{
if (curve.Length < minlength)
{
String mess = "Line is shorter than " +
String.Format("{0:0.00}", minlength) + " " + Globals.GetSpatRefUnitName(inFeature.Shape.SpatialReference, true) +
", aborting edit.";
AAState.WriteLine(" " + mess);
MessageBox.Show(mess, "Line too short");
AAState._editor.AbortOperation();
return false;
}
}
else
{
AAState.WriteLine(" ERROR: Feature is not a Line");
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" Error MINIMUM_LENGTH \n" + ex.Message);
}
finally
{
AAState.WriteLine(" Finished MINIMUM_LENGTH");
}
break;
}
case "LINK_TABLE_ASSET":
try
{
intersectLayerName = "";
intersectTable = null;
intersectLayer = null;
List<string> intersectLayerFieldNameList = new List<string>();
List<int> intersectFieldPosList = new List<int>();
AAState.WriteLine(" Trying LINK_TABLE_ASSET");
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // Feature Layer only
intersectLayerName = args[0].ToString();
break;
case 2: // Feature Layer| Field to copy
intersectLayerName = args[0].ToString();
intersectLayerFieldNameList = new List<string>(args[1].ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
break;
case 3: // Feature Layer| Field to copy | for future
intersectLayerName = args[0].ToString();
intersectLayerFieldNameList = new List<string>(args[1].ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
//sequenceColumnName = args[2].ToString();
break;
default:
AAState.WriteLine(" ERROR: Unsupported Value Method: " + valData);
continue;
// break;
}
bool FCorLayerIntersect = true;
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref FCorLayerIntersect);
intersectTable = Globals.FindStandAloneTable(AAState._editor.Map, intersectLayerName);
if (intersectLayer != null)
{
////Find Area Field
foreach (string intersectLayerFieldName in intersectLayerFieldNameList)
{
intersectFieldPos = intersectLayer.FeatureClass.Fields.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(" ERROR: Asset feature Layer Field(" + intersectLayerFieldName + ") not found");
break;
}
else
{
intersectFieldPosList.Add(intersectFieldPos);
}
}
intersectLayerSelection = (IFeatureSelection)intersectLayer;
if (intersectLayerSelection.SelectionSet.Count == 0)
{
AAState.WriteLine(" ERROR: No assests selected in " + intersectLayerName);
break;
}
if (intersectLayerSelection.SelectionSet.Count > 1)
{
AAState.WriteLine(" ERROR: To many assests are selected in " + intersectLayerName);
break;
}
intersectLayerSelection.SelectionSet.Search(null, true, out cCurs);
}
else if (intersectTable != null)
{
if (intersectTable.Table == null)
{
AAState.WriteLine(" ERROR: Asset Layer(" + intersectLayerName + ") not found");
break;
}
////Find Area Field
//intersectFieldPos = intersectTable.Table.Fields.FindField(intersectLayerFieldName);
//if (intersectFieldPos < 0)
//{
// AAState.WriteLine(" ERROR: Asset Layer Field(" + intersectLayerFieldName + ") not found");
// break;
//}
foreach (string intersectLayerFieldName in intersectLayerFieldNameList)
{
intersectFieldPos = intersectTable.Table.Fields.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(" ERROR: Asset Layer Field(" + intersectLayerFieldName + ") not found");
break;
}
else
{
intersectFieldPosList.Add(intersectFieldPos);
}
}
intersectTableSelection = (ITableSelection)intersectTable;
if (intersectTableSelection.SelectionSet.Count == 0)
{
AAState.WriteLine(" ERROR: No assests selected in " + intersectLayerName);
break;
}
if (intersectTableSelection.SelectionSet.Count > 1)
{
AAState.WriteLine(" ERROR: To many assests are selected in " + intersectLayerName);
break;
}
intersectTableSelection.SelectionSet.Search(null, true, out cCurs);
}
else
{
AAState.WriteLine(" ERROR: Asset Layer(" + intersectLayerName + ") not found");
break;
}
IRow row;
while ((row = cCurs.NextRow()) != null)
{
int idx = 0;
foreach (int fldIdxInt in intersectFieldPosList)
{
if (idx >= intFldIdxs.Count)
continue;
string val = row.get_Value(fldIdxInt).ToString();
if (inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(intFldIdxs[idx], val);
else if (inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeSmallInteger || inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeInteger)
{
if (Globals.IsNumeric(val))
{
inObject.set_Value(intFldIdxs[idx], Convert.ToInt32(val));
}
else
{
AAState.WriteLine(" ERROR: Field is a number and Value is not" + val);
}
}
else if (inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeSingle || inObject.Fields.get_Field(intFldIdxs[idx]).Type == esriFieldType.esriFieldTypeDouble)
{
if (Globals.IsNumeric(val))
{
inObject.set_Value(intFldIdxs[idx], Convert.ToDouble(val));
}
else
{
AAState.WriteLine(" ERROR: Field is a number and Value is not:" + val);
}
}
else
{
inObject.set_Value(intFldIdxs[idx], val);
}
idx++;
}
}
if (row != null)
Marshal.ReleaseComObject(cCurs);
row = null;
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: LINK_TABLE_ASSET" + Environment.NewLine + ex.Message);
}
finally
{
if (cCurs != null)
{
Marshal.ReleaseComObject(cCurs);
GC.Collect(300);
GC.WaitForFullGCComplete();
cCurs = null;
}
AAState.WriteLine(" Finished: LINK_TABLE_ASSET");
}
break;
case "GET_ADDRESS_FROM_CENTERLINE":
AAState.WriteLine(" Trying GET_ADDRESS_FROM_CENTERLINE");
List<IPoint> pPnts = null;
try
{
if ((valData != null) && (inFeature != null))
{
sourceLayerName = "";
string[] sourceFieldNames = null;
searchDistance = 0;
// Parse arguments
args = valData.Split('|');
if (args.Length == 2)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
searchDistance = 2;
AAState.WriteLine(" WARNING: search distance as not specified, defaulting to 0");
}
else if (args.Length == 3)
{
sourceLayerName = args[0].ToString().Trim();
sourceFieldNames = args[1].ToString().Split(',');
Double.TryParse(args[2], out searchDistance);
}
else
{
AAState.WriteLine(" ERROR: the valuemethod is not defined properly for this rule");
continue;
}
//Globals.GetAddressInfo(
if (sourceFieldNames.Length != 5)
{
AAState.WriteLine(" ERROR: the valuemethod fields part does not have enough fields listed");
continue;
}
//AAState.WriteLine(" Looking for layer: " + sourceLayerName);
boolLayerOrFC = false;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
// Globals.GetNearestFeature((inObject as IFeature).Shape,
pPnts = Globals.GetGeomCenter(inObject as IFeature);
if (pPnts.Count != 0)
{
AddressInfo pRetValu = Globals.GetAddressInfo(ArcMap.Application, pPnts[0] as IPoint, sourceLayerName,
sourceFieldNames[0].Trim(), sourceFieldNames[1].Trim(), sourceFieldNames[2].Trim(), sourceFieldNames[3].Trim(), sourceFieldNames[4].Trim(), false, searchDistance);
if (pRetValu != null)
{
if (pRetValu.Messages == "")
{
bool rightSide = true;
IPoint pPnt = Globals.GetPointOnLine((inObject as IFeature).Shape as IPoint, pRetValu.StreetGeometry as IPolyline, 400, out rightSide);
try
{
if (strFldNames.Count == 2)
{
if (intFldIdxs[0] != -1)
{
if (rightSide)
{
inObject.set_Value(intFldIdxs[0], pRetValu.RightAddress);
}
else
{
inObject.set_Value(intFldIdxs[0], pRetValu.LeftAddress);
}
}
if (intFldIdxs[1] != -1)
inObject.set_Value(intFldIdxs[1], pRetValu.StreetName);
}
else
{
if (intFldIdxs[0] != -1)
{
if (rightSide)
{
inObject.set_Value(intFldIdxs[0], pRetValu.RightAddress + " " + pRetValu.StreetName);
}
else
{
inObject.set_Value(intFldIdxs[0], pRetValu.LeftAddress + " " + pRetValu.StreetName);
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Error setting field values, GET_ADDRESS_FROM_CENTERLINE" + Environment.NewLine + ex.Message);
}
}
else
{
AAState.WriteLine(" ERROR: Error getting address info from the centerline: " + pRetValu.Messages);
}
}
else
{
AAState.WriteLine(" ERROR: Error getting address info from the centerline, GET_ADDRESS_FROM_CENTERLINE");
}
}
else
{
AAState.WriteLine(" ERROR: Error getting Location, GET_ADDRESS_FROM_CENTERLINE");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GET_ADDRESS_FROM_CENTERLINE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GET_ADDRESS_FROM_CENTERLINE");
pPnts = null;
}
break;
case "GET_ADDRESS_USING_GEOCODER":
{
IReverseGeocoding reverseGeocoding = null;
IAddressGeocoding addressGeocoding = null;
IPoint revGCLoc = null;
IFields matchFields = null;
IField shapeField = null;
IReverseGeocodingProperties reverseGeocodingProperties = null;
IPropertySet addressProperties = null;
IAddressInputs addressInputs = null;
IFields addressFields = null;
object key = null;
object value = null;
try
{
AAState.WriteLine(" Trying GET_ADDRESS_USING_GEOCODER");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 2)
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
}
else
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
AAState.WriteLine(" Trying to get address locator");
reverseGeocoding = Globals.OpenLocator(args[0], args[1]);
if (reverseGeocoding == null)
{
AAState.WriteLine(" ERROR: Reverse Address not locator found");
break;
}
AAState.WriteLine(" Reverse Address locator found");
AAState.WriteLine(" Retrieving Location to reverse geocode");
revGCLoc = Globals.GetGeomCenter(inFeature)[0];
AAState.WriteLine(" Location retrieved");
// Create a Point at which to find the address.
addressGeocoding = (IAddressGeocoding)reverseGeocoding;
matchFields = addressGeocoding.MatchFields;
int shpFld = matchFields.FindField("Shape");
shapeField = matchFields.get_Field(shpFld);
AAState.WriteLine(" Setting distance");
// Set the search tolerance for reverse geocoding.
reverseGeocodingProperties = (IReverseGeocodingProperties)reverseGeocoding;
reverseGeocodingProperties.SearchDistance = 100;
reverseGeocodingProperties.SearchDistanceUnits = esriUnits.esriFeet;
reverseGeocoding.InitDefaults();
// Find the address nearest the Point.
addressProperties = reverseGeocoding.ReverseGeocode(revGCLoc, false);
// Print the address properties.
addressInputs = (IAddressInputs)reverseGeocoding;
addressFields = addressInputs.AddressFields;
addressProperties.GetAllProperties(out key, out value);
string tempVal = "";
for (int i = 0; i < addressFields.FieldCount; i++)
{
IField addressField = addressFields.get_Field(i);
if (tempVal == "")
{
tempVal = addressProperties.GetProperty(addressField.Name).ToString();
}
else
{
tempVal = tempVal + ", " + addressProperties.GetProperty(addressField.Name).ToString();
}
}
inFeature.set_Value(intFldIdxs[0], tempVal);
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GET_ADDRESS_USING_GEOCODER" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GET_ADDRESS_USING_GEOCODER");
reverseGeocoding = null;
addressGeocoding = null;
revGCLoc = null;
matchFields = null;
shapeField = null;
reverseGeocodingProperties = null;
addressProperties = null;
addressInputs = null;
addressFields = null;
key = null;
value = null;
}
break;
}
case "GET_ADDRESS_USING_ARCGIS_SERVICE": //ARGS: url
try
{
IPoint revGCLoc = null;
AAState.WriteLine(" Trying GET_ADDRESS_USING_ARCGIS_SERVICE");
if (fieldObj.Type == esriFieldType.esriFieldTypeString)
{
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
args = valData.Split('|');
revGCLoc = Globals.GetGeomCenter(inFeature)[0];
int wkid = inFeature.Shape.SpatialReference.FactoryCode;
if (revGCLoc != null)
{
//Test for user specified URL
if (valData.Trim() != "")
{
if (args.Length == 2)
{
wkid = Convert.ToInt32(args[1]);
}
if (Globals.IsUrl(args[0]))
{
locatorURL = args[0];
/////locatorURL.TrimEnd(char[] );
if (!(locatorURL.EndsWith(reverseGeocodeStr)))
{
if (!(locatorURL.EndsWith(GeocodeStr)))
{
if (!(locatorURL.EndsWith("/")))
{
locatorURL += "/" + GeocodeStr + "/" + reverseGeocodeStr;
}
else
{
locatorURL += GeocodeStr + "/" + reverseGeocodeStr;
}
}
else
{
if (!(locatorURL.EndsWith("/")))
{
locatorURL += "/" + reverseGeocodeStr;
}
else
{
locatorURL += reverseGeocodeStr;
}
}
}
}
else if (args[0] == "TA_Streets_US_10")
{
locatorURL = _agsOnlineLocators + args[0] + GeocodeStr + "/" + reverseGeocodeStr;
// wkid = 102100;
}
else if (args[0] == "TA_Address_NA_10" || args[0] == "TA_Address_EU")
{
locatorURL = _agsOnlineLocators + args[0] + GeocodeStr + "/" + reverseGeocodeStr;
// wkid = 4326;
}
//Default to AGS Online USA geocode service
else if (_agsOnlineLocators.Substring(_agsOnlineLocators.LastIndexOf('/', _agsOnlineLocators.Length - 2)).Contains("Locator"))
{
locatorURL = _agsOnlineLocators + "TA_Address_NA_10" + GeocodeStr + "/" + reverseGeocodeStr;
// wkid = 4326;
}
else
{
locatorURL = _agsOnlineLocators + GeocodeStr + "/" + reverseGeocodeStr; ;
// wkid = 4326;
}
}
else
{
if (_agsOnlineLocators.Substring(_agsOnlineLocators.LastIndexOf('/', _agsOnlineLocators.Length - 2)).Contains(GeocodeStr))
{
locatorURL = _agsOnlineLocators + "/" + reverseGeocodeStr;
// wkid = 4326;
}
else
{
_agsOnlineLocators = _agsOnlineLocators + "/" + GeocodeStr;
locatorURL = _agsOnlineLocators + "/" + reverseGeocodeStr;
// wkid = 4326;
}
}
if (!locatorURL.ToUpper().Contains("/REST/"))
{
AAState.WriteLine(" ERROR: Thre url to the geocoder is not to the rest endpoint");
}
else
{
//Copy point from this current feature
_copyPoint = revGCLoc;//inFeature.ShapeCopy as IPoint;
//Project point to WGS84
StreamReader reader = null;
HttpWebRequest request = null;
try
{
// Create the web request
request = WebRequest.Create(_agsOnlineLocators) as HttpWebRequest;
// Get response
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
// Get the response stream
reader = new StreamReader(response.GetResponseStream());
string resp = reader.ReadToEnd();
resp = resp.Substring(resp.IndexOf("Spatial Reference:"));
resp = resp.Substring(0, resp.IndexOf("<br/>"));
resp = resp.Substring(resp.IndexOf("</b>") + 4);
wkid = Convert.ToInt32(resp.Split(' ')[0]);
//XmlDictionaryReader xr = JsonReaderWriterFactory.CreateJsonReaderreader.ReadToEnd(), XmlDictionaryReaderQuotas.Max);
//doc.Load(reader.ReadToEnd());
// Console application output
// Console.WriteLine(reader.ReadToEnd());
}
}
catch
{
AAState.WriteLine(" Error getting service projection information");
wkid = 4326;
}
finally
{
reader = null;
request = null;
}
_copyPoint.Project(Globals.CreateSpatRef(wkid));
//Include location parameters in URL
string results = Globals.FormatLocationRequest(locatorURL, _copyPoint.X, _copyPoint.Y, 100);
//Send and receieve the request
WebRequest req = null;
WebResponse res = null;
XmlDictionaryReader xr = null;
XmlDocument doc = null;
try
{
req = WebRequest.Create(results);
res = req.GetResponse();
//Convert response from JSON to XML
doc = new XmlDocument();
using (Stream s = res.GetResponseStream())
{
xr = JsonReaderWriterFactory.CreateJsonReader(s, XmlDictionaryReaderQuotas.Max);
doc.Load(xr);
xr.Close();
s.Close();
string val = "";
for (int h = 0; h < doc.DocumentElement.FirstChild.ChildNodes.Count - 1; h++)
{
if (doc.DocumentElement.FirstChild.ChildNodes[h].Name.Contains("Match") == false)
{
if (val == "")
{
val = doc.DocumentElement.FirstChild.ChildNodes[h].InnerText;
}
else
{
val = val + ", " + doc.DocumentElement.FirstChild.ChildNodes[h].InnerText;
}
}
}
val = val.Trim();
inFeature.set_Value(intFldIdxs[0], val);
}
}
catch
{
}
finally
{
req = null;
res = null;
xr = null;
doc = null;
}
}
}
else
{
AAState.WriteLine(" Could not get location to Reverse Geocode");
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GET_ADDRESS_USING_ARCGIS_SERVICE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GET_ADDRESS_USING_ARCGIS_SERVICE");
}
break;
case "TIMESTAMP":
try
{
AAState.WriteLine(" Trying: TIMESTAMP");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length > 0)
{
try
{
//if (args[0].ToString() == "DATE")
//{
// if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
// inObject.set_Value(intFldIdxs[0], DateTime.Now.Date);
// else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
// inObject.set_Value(intFldIdxs[0], DateTime.Now.Date.ToString());
//}
//else if (args[0].ToString() == "TIME")
//{
// if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
// inObject.set_Value(intFldIdxs[0], DateTime.Now.TimeOfDay);
// else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
// inObject.set_Value(intFldIdxs[0], DateTime.Now.TimeOfDay.ToString());
//}
//else
//{
if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
inObject.set_Value(intFldIdxs[0], DateTime.Now);
else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString(args[0]));
// }
}
catch
{
AAState.WriteLine(" ERROR: Date/Time Format is invalid");
}
}
else
{
AAState.WriteLine(" Value info is empty");
if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
inObject.set_Value(intFldIdxs[0], DateTime.Now);
else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString());
}
}
else
{
AAState.WriteLine(" Value info is empty");
if (fieldObj.Type == esriFieldType.esriFieldTypeDate)
inObject.set_Value(intFldIdxs[0], DateTime.Now);
else if (fieldObj.Type == esriFieldType.esriFieldTypeString)
inObject.set_Value(intFldIdxs[0], DateTime.Now.ToString());
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TIMESTAMP " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TIMESTAMP");
}
break;
case "LAST_VALUE":
try
{
AAState.WriteLine(" Trying: LAST_VALUE");
bool CheckForValue = false;
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length > 0)
{
if (args[0].ToString().ToUpper() == "TRUE")
{
CheckForValue = true;
}
}
//if (args.Length != 2)
//{
// AAState.WriteLine(" ERROR: Format of valdata incorrect");
// break;
//}
}
else
{
AAState.WriteLine(" Value info is empty");
}
if (CheckForValue && (inObject.get_Value(intFldIdxs[0]) != null && inObject.get_Value(intFldIdxs[0]) != DBNull.Value))
{
}
else
{
if (mode == "ON_CREATE")
{
lastValue = AAState.lastValueProperties.GetProperty(strFldNames[0]);
if (lastValue != null)
{
inObject.set_Value(intFldIdxs[0], lastValue);
AAState.WriteLine(" " + strFldNames[0] + ": " + lastValue);
}
else
{
if (inObject.get_Value(intFldIdxs[0]) != null)
{
AAState.lastValueProperties.SetProperty(strFldNames[0], inObject.get_Value(intFldIdxs[0]));
}
}
}
else if (mode == "ON_CHANGE")//&& inObject.get_Value(intFldIdxs[0]) == null
{
IRowChanges pRowCh = inObject as IRowChanges;
changed = pRowCh.get_ValueChanged(intFldIdxs[0]);
if (!changed)
{
lastValue = AAState.lastValueProperties.GetProperty(strFldNames[0]);
if (lastValue != null)
{
inObject.set_Value(intFldIdxs[0], lastValue);
AAState.WriteLine(" " + strFldNames[0] + ": " + lastValue);
}
}
}
}
}
catch (Exception ex)
{
//if (mode == "ON_CREATE")
//{
// if (inObject.get_Value(intFldIdxs[0]) != null)
// {
// AAState.lastValueProperties.SetProperty(strFldNames[0], inObject.get_Value(intFldIdxs[0]));
// }
//}
//else
//{
AAState.WriteLine(" ERROR: LAST_VALUE " + ex.Message);
// }
}
finally
{
AAState.WriteLine(" Finished: LAST_VALUE");
}
break;
case "X_COORDINATE":
try
{
AAState.WriteLine(" Trying: X_COORDINATE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.Shape as IPoint;
inFeature.set_Value(intFldIdxs[0], _copyPoint.X);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
if (valData == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].X);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.FromPoint.X);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.ToPoint.X);
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].X);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolygon)[0].X);
}
else
{
AAState.WriteLine(" ERROR: Unsupported Geometry");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: X_COORDINATE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: X_COORDINATE");
}
break;
case "Y_COORDINATE":
try
{
AAState.WriteLine(" Trying: Y_COORDINATE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.Shape as IPoint;
inFeature.set_Value(intFldIdxs[0], _copyPoint.Y);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
if (valData == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].Y);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.FromPoint.Y);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.ToPoint.Y);
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].Y);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolygon)[0].Y);
}
else
{
AAState.WriteLine(" ERROR: Unsupported Geometry");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Y_COORDINATE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: Y_COORDINATE");
}
break;
case "LATITUDE":
try
{
AAState.WriteLine(" Trying: LATITUDE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.ShapeCopy as IPoint;
_copyPoint.Project(AAState._sr1);
inFeature.set_Value(intFldIdxs[0], _copyPoint.Y);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.ShapeCopy as IPolyline;
_copyPolyline.Project(AAState._sr1);
if (valData == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].Y);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.FromPoint.Y);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.ToPoint.Y);
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].Y);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
_copyPolygon.Project(AAState._sr1);
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolygon)[0].Y);
}
else
{
AAState.WriteLine(" ERROR: Unsupported Geometry");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" Error: LATITUDE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: LATITUDE");
}
break;
case "LONGITUDE":
try
{
AAState.WriteLine(" Trying: LONGITUDE");
if ((inFeature != null) && (inFeature.Shape != null) && !(inFeature.Shape.IsEmpty))
{
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
{
_copyPoint = inFeature.ShapeCopy as IPoint;
_copyPoint.Project(AAState._sr1);
inFeature.set_Value(intFldIdxs[0], _copyPoint.X);
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
_copyPolyline = inFeature.Shape as IPolyline;
_copyPolyline.Project(AAState._sr1);
if (valData == "")
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].X);
}
else
{
args = valData.Split('|');
if (args[0].ToUpper() == "S")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.FromPoint.X);
}
else if (args[0].ToUpper() == "E")
{
inFeature.set_Value(intFldIdxs[0], _copyPolyline.ToPoint.X);
}
else
{
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolyline)[0].X);
}
}
}
else if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolygon)
{
_copyPolygon = inFeature.ShapeCopy as IPolygon;
_copyPolygon.Project(AAState._sr1);
inFeature.set_Value(intFldIdxs[0], Globals.GetGeomCenter(_copyPolygon)[0].X);
}
else
{
AAState.WriteLine(" ERROR: Unsupported Geometry");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: LONGITUDE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: LONGITUDE");
}
break;
case "FIELD":
try
{
AAState.WriteLine(" Trying: Field");
// verify that field to copy exists
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
fieldCopy = inObject.Fields.FindField(args[0] as string);
if (fieldCopy > -1)
{
bool useDisplayValue = true;
if (args.Length == 2)
{
if (args[1].ToUpper() == "CODE")
useDisplayValue = false;
}
//if (mode == "ON_CREATE")
//{
try
{
if (useDisplayValue)
{
inObject.set_Value(intFldIdxs[0], Globals.GetDomainDisplay(inObject.get_Value(fieldCopy), inObject as IFeature, inObject.Fields.get_Field(fieldCopy)));
AAState.WriteLine(" Value set");
}
else
{
inObject.set_Value(intFldIdxs[0], inObject.get_Value(fieldCopy));
AAState.WriteLine(" Value set");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: " + ex.Message);
}
//if (mode == "ON_CHANGE")
//{
// //copy value only if current field is empty
// if (inObject.get_Value(intFldIdxs[0]).ToString() == "")
// inObject.set_Value(intFldIdxs[0], inObject.get_Value(fieldCopy));
//}
}
else
{
AAState.WriteLine(" " + valData + " is not found");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Field: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: Field");
}
break;
//CURRENT_USER
//Value Data options:
//U - windows username only
//W or (blank) - full username including domain i.e. domain\username
//D - database user if available and not dbo
case "CURRENT_USER":
try
{
AAState.WriteLine(" Trying: CURRENT_USER");
lastEditorName = AAState._currentUserInfo.GetCurrentUser(valData, fieldObj.Length);
AAState.WriteLine(" Usernmae: " + lastEditorName);
if (!String.IsNullOrEmpty(lastEditorName))
{
inObject.set_Value(intFldIdxs[0], lastEditorName);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: CURRENT_USER: "******" Finished: CURRENT_USER");
}
break;
case "JUNCTION_ROTATION":
try
{
AAState.WriteLine(" Trying: JUNCTION_ROTATION");
if ((inFeature != null))
{
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolGeographic;
args = null;
AAState.rCalc.UseDiameter = false;
AAState.rCalc.DiameterFieldName = "";
AAState.rCalc.SpinAngle = 0;
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length == 0)
{
// if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolGeographic;
}
else if (args.Length == 1)
{
if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolArithmetic;
}
else if (args.Length == 2)
{
if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolArithmetic;
if (Globals.IsNumeric(args[1].ToString()))
AAState.rCalc.SpinAngle = Convert.ToDouble(args[1]);
}
else if (args.Length == 3)
{
if (args[0].Substring(0, 1).ToLower() == "a")
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolArithmetic;
if (Globals.IsNumeric(args[1].ToString()))
AAState.rCalc.SpinAngle = Convert.ToDouble(args[1]);
AAState.rCalc.UseDiameter = true;
AAState.rCalc.DiameterFieldName = args[2].ToString();
}
else
{
AAState.rCalc.RotationType = esriSymbolRotationType.esriRotateSymbolGeographic;
}
}
AAState.WriteLine(" " + AAState.rCalc.RotationType.ToString() + " is being used");
rotationAngle = AAState.rCalc.GetRotationUsingConnectedEdges(inFeature);
if (rotationAngle == null)
{
AAState.WriteLine(" Rotation Angle not found or errored out");
continue;
}
//Accept optional second argument to provide extra rotation
//if ((args != null) && (args.Length > 1) && (Globals.IsInteger(args[1])))
// rotationAngle += System.Convert.ToInt32(args[1]);
if (rotationAngle != -1)
{
AAState.WriteLine(" Rotation Angle set to: " + rotationAngle.ToString());
inObject.set_Value(intFldIdxs[0], rotationAngle);
AAState.WriteLine(" Rotation Angle set");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: JUNCTION_ROTATION \r\n" + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: JUNCTION_ROTATION");
}
break;
//For Release: 1.2
//New Dynamic Value Method: Length - stores calculated length of line feature
case "LENGTH":
try
{
AAState.WriteLine(" Trying: LENGTH");
if (inFeature != null)
{
curve = (ICurve)inFeature.Shape;
if (curve != null)
{
inObject.set_Value(intFldIdxs[0], curve.Length);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: LENGTH: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: LENGTH");
}
break;
//Release: 1.2
//New Dynamic Value Method: SET_MEASURES - stores calculated M values (from 0 to length of line) for line feature
//Value Data options:
//P = Percent - Ms will be zero to 100
//default - Ms will be zero to length of line
case "SET_MEASURES":
try
{
AAState.WriteLine(" Trying: SET_MEASURES");
if (inFeature != null)
{
curve = inFeature.Shape as ICurve;
mseg = inFeature.Shape as IMSegmentation;
if (curve != null && mseg != null)
if (valData != null && valData != "" && valData.Substring(0, 1).ToUpper() == "P")
mseg.SetAndInterpolateMsBetween(0, 100);
else
mseg.SetAndInterpolateMsBetween(0, curve.Length);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: SET_MEASURES: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: SET_MEASURES");
}
break;
//case "EDGE_INTERSECT_SECOND":
// try
// {
// if (inFeature != null)
// {
// netFeat = inFeature as INetworkFeature;
// if (netFeat != null)
// {
// if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
// {
// iJuncFeat = (IJunctionFeature)netFeat;
// // IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
// ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
// if (iSJunc == null)
// break;
// if (iSJunc.EdgeFeatureCount <= 1)
// break;
// iEdgeFeat = iSJunc.get_EdgeFeature(1);
// // verify that field (in junction) to copy exists
// IRow pRow = iEdgeFeat as IRow;
// juncField = pRow.Fields.FindField(valData as string);
// if (juncField > -1)
// {
// inObject.set_Value(intFldIdxs[0], pRow.get_Value(juncField));
// }
// }
// }
// }
// }
// catch
// {
// }
// break;
//case "EDGE_INTERSECT_FIRST":
// try
// {
// if (inFeature != null)
// {
// netFeat = inFeature as INetworkFeature;
// if (netFeat != null)
// {
// if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
// {
// iJuncFeat = (IJunctionFeature)netFeat;
// // IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
// ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
// if (iSJunc == null)
// break;
// if (iSJunc.EdgeFeatureCount <= 0)
// break;
// iEdgeFeat = iSJunc.get_EdgeFeature(0);
// IRow pRow = iEdgeFeat as IRow;
// juncField = pRow.Fields.FindField(valData as string);
// if (juncField > -1)
// {
// inObject.set_Value(intFldIdxs[0], pRow.get_Value(juncField));
// }
// }
// }
// }
// }
// catch
// {
// }
// break;
//Release: 2.0
//New Dynamic Value Method: TO_EDGE_FIELD transfers a field value from a connected egde feature to a junction feature
//Takes value from the frist edge whose "TO" point connects with this junction
case "TO_EDGE_FIELD":
try
{
AAState.WriteLine(" Trying: TO_EDGE_FIELD");
if (inFeature != null)
{
if (valData == null)
{
AAState.WriteLine(" Value info is null");
break;
}
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iEdgeFeat).Class));
AAState.WriteLine(" Layer restriction found, Class name of junction is: " + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" Layer restriction does not match, breaking");
continue;
}
AAState.WriteLine(" Layer restriction matches, checking for field restriction");
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iEdgeFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
//IFeature pTest = ((IFeature)iEdgeFeat);
if (((IFeature)iEdgeFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(" Values Match");
}
else
{
AAState.WriteLine(" Values dont match Match");
continue;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + " was not found");
}
}
else
{
AAState.WriteLine(" Missing Field restriction and value info");
}
}
iJuncFeat = (IJunctionFeature)iEdgeFeat.FromJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(pRow.Fields, netField);
if (juncField > -1)
{
inObject.set_Value(intFldIdxs[0], pRow.get_Value(juncField));
}
else
{
AAState.WriteLine(" " + netField + " field not found in edge");
}
pRow = null;
break;
}
}
catch
{
}
iSJunc = null;
}
}
else
{
AAState.WriteLine(" No Connected Edges Found");
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_EDGE_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_EDGE_FIELD");
}
break;
//Release: 2.0
//New Dynamic Value Method: FROM_EDGE_FIELD transfers a field value from a connected egde feature to a junction feature
//Takes value from the frist edge whose "FROM" point connects with this junction
case "FROM_EDGE_FIELD":
try
{
AAState.WriteLine(" Trying: FROM_EDGE_FIELD");
if (inFeature != null)
{
if (valData == null)
{
AAState.WriteLine(" Value info is null");
break;
}
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
if (iSJunc.EdgeFeatureCount <= 0)
break;
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iEdgeFeat).Class));
AAState.WriteLine(" Layer restriction found, Class name of junction is: " + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" Layer restriction does not match, breaking");
continue;
}
AAState.WriteLine(" Layer restriction matches, checking for field restriction");
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iEdgeFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
//IFeature pTest = ((IFeature)iEdgeFeat);
if (((IFeature)iEdgeFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(" Values Match");
}
else
{
AAState.WriteLine(" Values dont match Match");
continue;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + " was not found");
}
}
else
{
AAState.WriteLine(" Missing Field restriction and value info");
}
}
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(pRow.Fields, netField);
if (juncField > -1)
{
inObject.set_Value(intFldIdxs[0], pRow.get_Value(juncField));
}
else
{
AAState.WriteLine(" " + iSJunc + " field not found");
}
pRow = null;
break;
}
}
catch
{
AAState.WriteLine(" error ");
}
iSJunc = null;
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: FROM_EDGE_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: FROM_EDGE_FIELD");
}
break;
case "TO_EDGE_STATS":
try
{
if (valData == null) break;
args = valData.Split('|');
string statType = "MAX";
switch (args.GetLength(0))
{
case 1:
sourceFieldName = args[0].ToString();
break;
case 2:
sourceFieldName = args[0].ToString();
statType = args[1].ToString();
break;
default: break;
}
AAState.WriteLine(" Trying: TO_EDGE_STATS");
int AverageCount = 0;
double result = -999999.1;
string textRes = "";
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(" Feature is a network feature");
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(" Feature is a junction feature");
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
AAState.WriteLine(" Checking if Edge is From or To");
iJuncFeat = iEdgeFeat.FromJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
AAState.WriteLine(" Edge is a To-Edge");
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(" Getting Field From To-Edge");
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" ERROR/WARNING: Non numeric value returned: " + test);
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
AAState.WriteLine(" Checking if Edge is From Edge, skipping");
}
}
catch
{
}
}//end loop
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Value was not set on feature: " + ex.Message);
}
}
else
{
AAState.WriteLine(" No Connected Edges Found");
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_EDGE_STATS");
}
break;
case "FROM_EDGE_STATS":
try
{
if (valData == null) break;
args = valData.Split('|');
string statType = "MAX";
switch (args.GetLength(0))
{
case 1:
sourceFieldName = args[0].ToString();
break;
case 2:
sourceFieldName = args[0].ToString();
statType = args[1].ToString();
break;
default: break;
}
AAState.WriteLine(" Trying: FROM_EDGE_STATS");
int AverageCount = 0;
double result = -999999.1;
string textRes = "";
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(" Feature is a network feature");
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(" Feature is a junction feature");
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
AAState.WriteLine(" Checking if Edge is From or To");
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
AAState.WriteLine(" Edge is a From-Edge");
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(" Getting Field From From-Edge");
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" ERROR/WARNING: Non numeric value returned: " + test);
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
AAState.WriteLine(" Checking if Edge is To Edge, skipping");
}
}
catch
{
}
}//end loop
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Value was not set on feature: " + ex.Message);
}
}
else
{
AAState.WriteLine(" No Connected Edges Found");
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_EDGE_STATS");
}
break;
case "EDGE_STATS":
try
{
if (valData == null) break;
args = valData.Split('|');
string statType = "MAX";
switch (args.GetLength(0))
{
case 1:
sourceFieldName = args[0].ToString();
break;
case 2:
sourceFieldName = args[0].ToString();
statType = args[1].ToString();
break;
default: break;
}
AAState.WriteLine(" Trying: EDGE_STATS");
int AverageCount = 0;
double result = -999999.1;
string textRes = "";
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(" Feature is a network feature");
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(" Feature is a junction feature");
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(" Getting Field From Edge");
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" ERROR/WARNING: Non numeric value returned: " + test);
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
catch
{
}
}//end loop
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Value was not set on feature: " + ex.Message);
}
}
else
{
AAState.WriteLine(" No Connected Edges Found");
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_EDGE_STATS");
}
break;
case "TO_EDGE_MULTI_FIELD_INTERSECT":
try
{
if (valData == null) break;
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int popFldIdx = 0;
if (args.GetLength(0) >= 2)
{
AAState.WriteLine(" Parsing Valueinfo");
sourceFieldName = args[0].ToString();
string[] fieldsToPop = args[1].ToString().Split(',');
AAState.WriteLine(" Trying: TO_EDGE_MULTI_FIELD_INTERSECT");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(" Feature is a network feature");
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(" Feature is a junction feature");
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
AAState.WriteLine(" Checking if Edge is From or To");
iJuncFeat = iEdgeFeat.FromJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
AAState.WriteLine(" Edge is a To-Edge");
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(" Getting Field From To-Edge");
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (fieldsToPop.Length == popFldIdx)
break;
int tempFieldNum = inObject.Fields.FindField(fieldsToPop[popFldIdx]);
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, test);
popFldIdx++;
}
}
else
{
AAState.WriteLine(" Checking if Edge is From Edge, skipping");
}
}
catch
{
}
}//end loop
}
else
{
AAState.WriteLine(" No Connected Edges Found");
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_EDGE_STATS");
}
break;
case "FROM_EDGE_MULTI_FIELD_INTERSECT":
try
{
if (valData == null) break;
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int popFldIdx = 0;
if (args.GetLength(0) >= 2)
{
AAState.WriteLine(" Parsing Valueinfo");
sourceFieldName = args[0].ToString();
string[] fieldsToPop = args[1].ToString().Split(',');
AAState.WriteLine(" Trying: FROM_EDGE_MULTI_FIELD_INTERSECT");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(" Feature is a network feature");
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(" Feature is a junction feature");
iJuncFeat = (IJunctionFeature)netFeat;
// IComplexJunctionFeature iCEd = iJuncFeat as IComplexJunctionFeature;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
AAState.WriteLine(" Checking if Edge is From or To");
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (((IFeature)iJuncFeat).Shape.Equals(inFeature.Shape))
{
AAState.WriteLine(" Edge is a From-Edge");
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(" Getting Field From From-Edge");
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
if (fieldsToPop.Length == popFldIdx)
break;
int tempFieldNum = inObject.Fields.FindField(fieldsToPop[popFldIdx]);
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, test);
popFldIdx++;
}
}
else
{
AAState.WriteLine(" Checking if Edge is To Edge, skipping");
}
}
catch
{
}
}//end loop
}
else
{
AAState.WriteLine(" No Connected Edges Found");
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_EDGE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_EDGE_STATS");
}
break;
case "FROM_JUNCTION_FIELD":
try
{
AAState.WriteLine(" Trying: FROM_JUNCTION_FIELD");
if (valData == null)
{
AAState.WriteLine(" Value info is null");
break;
}
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iEdgeFeat = (IEdgeFeature)netFeat;
iJuncFeat = iEdgeFeat.FromJunctionFeature;
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iJuncFeat).Class));
AAState.WriteLine(" Layer restriction found, Class name of junction is: " + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" Layer restriction does not match, breaking");
break;
}
AAState.WriteLine(" Layer restriction matches, checking for field restriction");
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
if (((IFeature)iJuncFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(" Values Match");
}
else
{
AAState.WriteLine(" Values dont match Match");
break;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + " was not found");
}
}
else
{
AAState.WriteLine(" Missing Field restriction and value info");
}
}
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netField);
if (juncField > -1)
{
inObject.set_Value(intFldIdxs[0], ((IFeature)iJuncFeat).get_Value(juncField));
}
else
AAState.WriteLine(" " + netField + " field not found");
}
else
AAState.WriteLine(" not an edge feature");
}
else
AAState.WriteLine(" Not a network feature");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: FROM_JUNCTION_FIELD: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: FROM_JUNCTION_FIELD");
}
break;
//Release: 1.2
//New Dynamic Value Method: TO_JUNCTION_FIELD transfers a field value from a junction connected at terminal end of a line feature
case "TO_JUNCTION_FIELD":
try
{
AAState.WriteLine(" Trying: TO_JUNCTION_FIELD");
if (valData == null)
{
AAState.WriteLine(" Value info is null");
break;
}
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
if (inFeature.FeatureType == esriFeatureType.esriFTComplexEdge || inFeature.FeatureType == esriFeatureType.esriFTSimpleEdge)
{
string netField = "";
string netRestrictFC = "";
string netRestrictField = "";
string netRestrictValue = "";
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
netField = args[0].ToString().Trim();
break;
case 2: // sequenceColumnName|sequenceFixedWidth
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
break;
case 4: // sequenceColumnName|sequenceFixedWidth|formatString
netField = args[0].ToString().Trim();
netRestrictFC = args[1].ToString().Trim();
netRestrictField = args[2].ToString().Trim();
netRestrictValue = args[3].ToString().Trim();
break;
default: break;
}
iEdgeFeat = (IEdgeFeature)netFeat;
iJuncFeat = iEdgeFeat.ToJunctionFeature;
if (netRestrictFC != "")
{
string strClsName = Globals.getClassName(((IDataset)((IFeature)iJuncFeat).Class));
AAState.WriteLine(" Layer restriction found, Class name of junction is: " + strClsName);
if (strClsName != netRestrictFC)
{
AAState.WriteLine(" Layer restriction does not match, breaking");
break;
}
AAState.WriteLine(" Layer restriction matches, checking for field restriction");
if (netRestrictField != "" && netRestrictValue != "")
{
int intTmpFld = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netRestrictField);
if (intTmpFld > -1)
{
if (((IFeature)iJuncFeat).get_Value(intTmpFld).ToString() == netRestrictValue)
{
AAState.WriteLine(" Values Match");
}
else
{
AAState.WriteLine(" Values dont match Match");
break;
}
}
else
{
AAState.WriteLine(" " + netRestrictField + " was not found");
}
}
else
{
AAState.WriteLine(" Missing Field restriction and value info");
}
}
// verify that field (in junction) to copy exists
juncField = Globals.GetFieldIndex(((IFeature)iJuncFeat).Fields, netField);
//juncField = ((IFeature)iJuncFeat).Fields.FindField(valData as string);
if (juncField > -1)
{
inObject.set_Value(intFldIdxs[0], ((IFeature)iJuncFeat).get_Value(juncField));
}
else
{
AAState.WriteLine(" " + netField + " field not found");
}
}
}
else
{
AAState.WriteLine(" not an edge feature");
}
}
else
{
AAState.WriteLine(" not an geometric network feature");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: TO_JUNCTION_FIELD:" + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: TO_JUNCTION_FIELD");
}
break;
//Release: 1.2
//New Dynamic Value Method: GENERATE_ID - uses value in specificed table and increments it as specified
case "GENERATE_ID":
try
{
AAState.WriteLine(" Trying: GENERATE_ID");
if (AAState._gentab != null)
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
formatString = "";
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
sequenceColumnName = args[0].ToString(); break;
case 2: // sequenceColumnName|sequenceFixedWidth
sequenceColumnName = args[0].ToString();
sequenceFixedWidth = args[1].ToString();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
sequenceColumnName = args[0].ToString();
sequenceFixedWidth = args[1].ToString();
formatString = args[2].ToString();
break;
default: break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
if (sequencePadding > 25)
{
AAState.WriteLine(" WARNING: you are trying to pad your id with a more than 25 - 0's");
AAState.WriteLine(" WARNING: " + sequencePadding + " 0's is what you have");
}
else if (sequencePadding > 50)
{
MessageBox.Show("You are trying to add 50 places to your ID, this is not supported, please fix your dynamic value table");
}
qFilter = new QueryFilterClass();
qFilter.WhereClause = "SEQNAME = '" + sequenceColumnName + "'";
cCurs = AAState._gentab.Update(qFilter, false);
sequenceColumnNum = AAState._gentab.Fields.FindField("SEQCOUNTER");
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = cCurs.NextRow();
if (row == null)
{
break;
}
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
sequenceValue += 1;
// _editEvents.OnChangeFeature -= OnChangeFeature;
// _editEvents.OnCreateFeature -= OnCreateFeature;
row.set_Value(sequenceColumnNum, sequenceValue);
AAState.WriteLine(" " + row.Fields.get_Field(sequenceColumnNum).AliasName + " changed to " + sequenceValue);
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
row.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
// _editEvents.OnChangeFeature += OnChangeFeature;
// _editEvents.OnCreateFeature += OnCreateFeature;
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
AAState.WriteLine(" ERROR: GENERATE_ID: Sequence Not Found");
}
else
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || formatString.ToLower().IndexOf("[seq]") == -1)
{
string setVal = (sequenceValue.ToString("D" + sequencePadding) + sequencePostfix).ToString();
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < setVal.Length && inObject.Fields.get_Field(intFldIdxs[0]).Length != 0)
{
AAState.WriteLine(" ERROR: " + sequenceValue + " is to long for field " + row.Fields.get_Field(sequenceColumnNum).AliasName);
}
else
{
inObject.set_Value(intFldIdxs[0], sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
AAState.WriteLine(" " + inObject.Fields.get_Field(intFldIdxs[0]).AliasName + " set to " + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
}
}
else
{
int locIdx = formatString.ToUpper().IndexOf("[SEQ]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 5);
formatString = formatString.Insert(locIdx, sequenceValue.ToString("D" + sequencePadding));
}
//formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < formatString.Length && inObject.Fields.get_Field(intFldIdxs[0]).Length != 0)
{
AAState.WriteLine(" ERROR: " + formatString + " is to long for field " + row.Fields.get_Field(sequenceColumnNum).AliasName);
}
else
{
inObject.set_Value(intFldIdxs[0], formatString);
AAState.WriteLine(" " + inObject.Fields.get_Field(intFldIdxs[0]).AliasName + " set to " + formatString);
}
}
else
{
inObject.set_Value(intFldIdxs[0], sequenceValue);
AAState.WriteLine(" " + sequenceColumnNum + " changed to " + sequenceValue);
}
}
}
else
{
AAState.WriteLine(" ERROR: GENERATE_ID table is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GENERATE_ID: " + ex.Message);
}
finally
{
if (cCurs != null)
{
Marshal.ReleaseComObject(cCurs);
GC.Collect(300);
GC.WaitForFullGCComplete();
cCurs = null;
}
AAState.WriteLine(" Finished: GENERATE_ID");
}
break;
case "GENERATE_ID_BY_INTERSECT":
try
{
AAState.WriteLine(" Trying: GENERATE_ID_BY_INTERSECT");
if (AAState._gentab != null && inFeature != null && !(inFeature.Shape.IsEmpty))
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
//genIdAreaFieldName = "";
intersectLayerName = "";
intersectLayerFieldName = "";
formatString = "";
intersectFieldPos = -1;
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
if (args.GetLength(0) < 3)
{
AAState.WriteLine(" ERROR: Improper value method");
break;
}
switch (args.GetLength(0))
{
case 3: //columnName
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
// genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
break;
case 4: // columnName|sequenceFixedWidth
//sequenceFixedWidth formats the sequence with leading zeros to create specified width
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
sequenceFixedWidth = Convert.ToString(0);
formatString = args[3].ToString();
break;
case 5: // columnName|sequenceFixedWidth|formatString
//formatString must contain [seq] and [id] and may contain [area] plus any desired text
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
sequenceFixedWidth = args[3].ToString();
formatString = args[4].ToString();
break;
default: break;
}
//Find Area Layer
// FindLayerByName(areaLayerName, out areaLayer);
boolLayerOrFC = true;
if (intersectLayerName.Contains("("))
{
string[] tempSplt = intersectLayerName.Split('(');
intersectLayerName = tempSplt[0];
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC);
}
if (intersectLayer == null)
{
AAState.WriteLine(" ERROR: Intersecting feature Layer(" + intersectLayerName + ") not found");
break;
}
//Find Area Field
intersectFieldPos = intersectLayer.FeatureClass.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(" ERROR: Intersecting feature Layer Field(" + intersectLayerFieldName + ") not found");
break;
}
//Find GenID Area Field
//genIdAreaFieldPos = areaLayer.FeatureClass.FindField(genIdAreaFieldName);
//if (genIdAreaFieldPos < 0) break;
//Perform spatial search
IGeometry pSearchGeo = (IGeometry)inFeature.ShapeCopy;
pSearchGeo.SpatialReference = (inFeature.Class as IGeoDataset).SpatialReference;
pSearchGeo.Project((intersectLayer as IGeoDataset).SpatialReference);
//sFilter = new SpatialFilterClass();
//sFilter.Geometry = pSearchGeo;
//sFilter.GeometryField = intersectLayer.FeatureClass.ShapeFieldName;
//sFilter.SubFields = intersectLayerFieldName;
//sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
sFilter = Globals.createSpatialFilter(intersectLayer, inFeature, false);
//if (boolLayerOrFC)
//{
// fCursor = intersectLayer.Search(sFilter, true);
//}
//else
//{
// fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
//}
pFS = (IFeatureSelection)intersectLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = intersectLayer.Search(sFilter, true);
}
}
else
{
fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
intersectValue = "-9999.1";
if (sourceFeature == null)
{
AAState.WriteLine(" ERROR: Intersecting feature not found");
break;
}
else
{
while (sourceFeature != null)
{
if (sourceFeature.Class != inFeature.Class)
{
intersectValue = sourceFeature.get_Value(intersectFieldPos).ToString();
break;
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
intersectValue = sourceFeature.get_Value(intersectFieldPos).ToString();
break;
}
sourceFeature = fCursor.NextFeature();
}
}
if (intersectValue == "-9999.1")
{
AAState.WriteLine(" ERROR: Intersecting feature not found");
break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
if (sequencePadding > 25)
{
AAState.WriteLine(" WARNING: you are trying to pad your id with a more than 25 - 0's");
AAState.WriteLine(" WARNING: " + sequencePadding + " 0's is what you have");
}
sequenceColumnName = sequenceColumnName + intersectValue;
AAState.WriteLine(" Looking for a field called " + sequenceColumnName + " in the generate ID table");
qFilter = new QueryFilterClass();
qFilter.WhereClause = "SEQNAME = '" + sequenceColumnName + "'";
cCurs = AAState._gentab.Update(qFilter, false);
sequenceColumnNum = AAState._gentab.Fields.FindField("SEQCOUNTER");
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = cCurs.NextRow();
if (row == null)
{
break;
}
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
sequenceValue += 1;
row.set_Value(sequenceColumnNum, sequenceValue);
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
row.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
AAState.WriteLine(" ERROR: Sequence number not found");
}
else
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || (formatString.ToUpper().IndexOf("[SEQ]") == -1 && formatString.ToUpper().IndexOf("[ID]") == -1))
inObject.set_Value(intFldIdxs[0], intersectValue + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
else
{
int locIdx = formatString.ToUpper().IndexOf("[ID]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 4);
formatString = formatString.Insert(locIdx, intersectValue);
}
// formatString = formatString.Replace("[id]", intersectValue);
// formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
locIdx = formatString.ToUpper().IndexOf("[SEQ]");
if (locIdx >= 0)
{
string sequenceValuePad = sequenceValue.ToString("D" + sequencePadding);
formatString = formatString.Remove(locIdx, 5);
formatString = formatString.Insert(locIdx, sequenceValuePad.ToString());
}
//
inObject.set_Value(intFldIdxs[0], formatString);
}
else
inObject.set_Value(intFldIdxs[0], sequenceValue);
}
}
else
{
AAState.WriteLine(" ERROR: GENERATE_ID table is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GENERATE_ID_BY_INTERSECT: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GENERATE_ID_BY_INTERSECT");
}
break;
//Modified for Release 1.2 (No longer uses ICalculator)
//Requires valid VBScript expression
//Can include string, numeric, and date fields by name in square brackets []
//Example: DateDiff("yyyy",[INSTALLDATE],Now())
case "GENERATE_ID_OLD":
try
{
AAState.WriteLine(" Trying: GENERATE_ID");
if (AAState._gentab != null)
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
formatString = "";
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1: // sequenceColumnName only
sequenceColumnName = args[0].ToString(); break;
case 2: // sequenceColumnName|sequenceFixedWidth
sequenceColumnName = args[0].ToString();
sequenceFixedWidth = args[1].ToString();
break;
case 3: // sequenceColumnName|sequenceFixedWidth|formatString
sequenceColumnName = args[0].ToString();
sequenceFixedWidth = args[1].ToString();
formatString = args[2].ToString();
break;
default: break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
if (sequencePadding > 25)
{
AAState.WriteLine(" WARNING: you are trying to pad your id with a more than 25 - 0's");
AAState.WriteLine(" WARNING: " + sequencePadding + " 0's is what you have");
}
else if (sequencePadding > 50)
{
MessageBox.Show("You are trying to add 50 places to your ID, this is not supported, please fix your dynamic value table");
}
//Check for sequence column in generate id table
sequenceColumnNum = AAState._gentab.FindField(sequenceColumnName);
if (AAState._gentab.FindField(sequenceColumnName) >= 0)
{
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = AAState._gentab.Update(null, false).NextRow();
if (row == null)
{
break;
}
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
sequenceValue += 1;
// _editEvents.OnChangeFeature -= OnChangeFeature;
// _editEvents.OnCreateFeature -= OnCreateFeature;
row.set_Value(sequenceColumnNum, sequenceValue);
AAState.WriteLine(" " + row.Fields.get_Field(sequenceColumnNum).AliasName + " changed to " + sequenceValue);
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
row.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
// _editEvents.OnChangeFeature += OnChangeFeature;
// _editEvents.OnCreateFeature += OnCreateFeature;
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
AAState.WriteLine(" ERROR: GENERATE_ID: Sequence Not Found");
}
else
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || formatString.ToLower().IndexOf("[seq]") == -1)
{
string setVal = (sequenceValue.ToString("D" + sequencePadding) + sequencePostfix).ToString();
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < setVal.Length && inObject.Fields.get_Field(intFldIdxs[0]).Length != 0)
{
AAState.WriteLine(" ERROR: " + sequenceValue + " is to long for field " + row.Fields.get_Field(sequenceColumnNum).AliasName);
}
else
{
inObject.set_Value(intFldIdxs[0], sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
AAState.WriteLine(" " + inObject.Fields.get_Field(intFldIdxs[0]).AliasName + " set to " + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
}
}
else
{
int locIdx = formatString.ToUpper().IndexOf("[SEQ]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 5);
formatString = formatString.Insert(locIdx, sequenceValue.ToString("D" + sequencePadding));
}
//formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < formatString.Length && inObject.Fields.get_Field(intFldIdxs[0]).Length != 0)
{
AAState.WriteLine(" ERROR: " + formatString + " is to long for field " + row.Fields.get_Field(sequenceColumnNum).AliasName);
}
else
{
inObject.set_Value(intFldIdxs[0], formatString);
AAState.WriteLine(" " + inObject.Fields.get_Field(intFldIdxs[0]).AliasName + " set to " + formatString);
}
}
else
{
inObject.set_Value(intFldIdxs[0], sequenceValue);
AAState.WriteLine(" " + sequenceColumnNum + " changed to " + sequenceValue);
}
}
}
else
{
AAState.WriteLine(" Sequence Field not found");
}
}
else
{
AAState.WriteLine(" ERROR: GENERATE_ID table is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GENERATE_ID: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GENERATE_ID");
}
break;
case "GENERATE_ID_BY_INTERSECT_OLD":
try
{
AAState.WriteLine(" Trying: GENERATE_ID_BY_INTERSECT");
if (AAState._gentab != null && inFeature != null && !(inFeature.Shape.IsEmpty))
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
//genIdAreaFieldName = "";
intersectLayerName = "";
intersectLayerFieldName = "";
formatString = "";
intersectFieldPos = -1;
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
if (args.GetLength(0) < 3)
{
AAState.WriteLine(" ERROR: Improper value method");
break;
}
switch (args.GetLength(0))
{
case 3: //columnName
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
// genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
break;
case 4: // columnName|sequenceFixedWidth
//sequenceFixedWidth formats the sequence with leading zeros to create specified width
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
sequenceFixedWidth = Convert.ToString(0);
formatString = args[3].ToString();
break;
case 5: // columnName|sequenceFixedWidth|formatString
//formatString must contain [seq] and [id] and may contain [area] plus any desired text
intersectLayerName = args[0].ToString();
intersectLayerFieldName = args[1].ToString();
//genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[2].ToString();
sequenceFixedWidth = args[3].ToString();
formatString = args[4].ToString();
break;
default: break;
}
//Find Area Layer
// FindLayerByName(areaLayerName, out areaLayer);
boolLayerOrFC = true;
if (intersectLayerName.Contains("("))
{
string[] tempSplt = intersectLayerName.Split('(');
intersectLayerName = tempSplt[0];
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
intersectLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, intersectLayerName, ref boolLayerOrFC);
}
if (intersectLayer == null)
{
AAState.WriteLine(" ERROR: Intersecting feature Layer(" + intersectLayerName + ") not found");
break;
}
//Find Area Field
intersectFieldPos = intersectLayer.FeatureClass.FindField(intersectLayerFieldName);
if (intersectFieldPos < 0)
{
AAState.WriteLine(" ERROR: Intersecting feature Layer Field(" + intersectLayerFieldName + ") not found");
break;
}
//Find GenID Area Field
//genIdAreaFieldPos = areaLayer.FeatureClass.FindField(genIdAreaFieldName);
//if (genIdAreaFieldPos < 0) break;
//Perform spatial search
IGeometry pSearchGeo = (IGeometry)inFeature.ShapeCopy;
pSearchGeo.SpatialReference = (inFeature.Class as IGeoDataset).SpatialReference;
pSearchGeo.Project((intersectLayer as IGeoDataset).SpatialReference);
//sFilter = new SpatialFilterClass();
//sFilter.Geometry = pSearchGeo;
//sFilter.GeometryField = intersectLayer.FeatureClass.ShapeFieldName;
//sFilter.SubFields = intersectLayerFieldName;
//sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
sFilter = Globals.createSpatialFilter(intersectLayer, inFeature, false);
//if (boolLayerOrFC)
//{
// fCursor = intersectLayer.Search(sFilter, true);
//}
//else
//{
// fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
//}
pFS = (IFeatureSelection)intersectLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = intersectLayer.Search(sFilter, true);
}
}
else
{
fCursor = intersectLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
intersectValue = "-9999.1";
if (sourceFeature == null)
{
AAState.WriteLine(" ERROR: Intersecting feature not found");
break;
}
else
{
while (sourceFeature != null)
{
if (sourceFeature.Class != inFeature.Class)
{
intersectValue = sourceFeature.get_Value(intersectFieldPos).ToString();
break;
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
intersectValue = sourceFeature.get_Value(intersectFieldPos).ToString();
break;
}
sourceFeature = fCursor.NextFeature();
}
}
if (intersectValue == "-9999.1")
{
AAState.WriteLine(" ERROR: Intersecting feature not found");
break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
if (sequencePadding > 25)
{
AAState.WriteLine(" WARNING: you are trying to pad your id with a more than 25 - 0's");
AAState.WriteLine(" WARNING: " + sequencePadding + " 0's is what you have");
}
sequenceColumnName = sequenceColumnName + intersectValue;
AAState.WriteLine(" Looking for a field called " + sequenceColumnName + " in the generate ID table");
sequenceColumnNum = AAState._gentab.FindField(sequenceColumnName);
if (sequenceColumnNum > -1)
{
AAState.WriteLine(" Field Found");
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = AAState._gentab.Update(qFilter, false).NextRow();
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
sequenceValue += 1;
row.set_Value(sequenceColumnNum, sequenceValue);
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
row.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
AAState.WriteLine(" ERROR: Sequence number not found");
}
else
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || (formatString.ToUpper().IndexOf("[SEQ]") == -1 && formatString.ToUpper().IndexOf("[ID]") == -1))
inObject.set_Value(intFldIdxs[0], intersectValue + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
else
{
int locIdx = formatString.ToUpper().IndexOf("[ID]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 4);
formatString = formatString.Insert(locIdx, intersectValue);
}
// formatString = formatString.Replace("[id]", intersectValue);
// formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
locIdx = formatString.ToUpper().IndexOf("[SEQ]");
if (locIdx >= 0)
{
formatString = formatString.Remove(locIdx, 5);
formatString = formatString.Insert(locIdx, sequenceValue.ToString());
}
//
inObject.set_Value(intFldIdxs[0], formatString);
}
else
inObject.set_Value(intFldIdxs[0], sequenceValue);
}
}
else
{
AAState.WriteLine(" ERROR: Field NOT Found");
}
}
else
{
AAState.WriteLine(" ERROR: GENERATE_ID table is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GENERATE_ID_BY_INTERSECT: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GENERATE_ID_BY_INTERSECT");
}
break;
//Modified for Release 1.2 (No longer uses ICalculator)
//Requires valid VBScript expression
//Can include string, numeric, and date fields by name in square brackets []
//Example: DateDiff("yyyy",[INSTALLDATE],Now())
case "GENERATE_ID_BY_AREA":
try
{
AAState.WriteLine(" Trying: GENERATE_ID_BY_AREA");
if (AAState._gentab != null && inFeature != null && !(inFeature.Shape.IsEmpty))
{
sequenceColumnName = "";
sequenceColumnNum = -1;
sequenceValue = -1;
sequenceFixedWidth = "";
sequencePadding = 0;
genIdAreaFieldName = "";
areaLayerName = "";
areaLayerFieldName = "";
formatString = "";
// Parse arguments
if (valData == null) break;
args = valData.Split('|');
if (args.GetLength(0) < 3)
{
AAState.WriteLine(" ERROR: Improper Value Method");
break;
}
switch (args.GetLength(0))
{
case 4: //columnName
areaLayerName = args[0].ToString();
areaLayerFieldName = args[1].ToString();
genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[3].ToString();
break;
case 5: // columnName|sequenceFixedWidth
//sequenceFixedWidth formats the sequence with leading zeros to create specified width
areaLayerName = args[0].ToString();
areaLayerFieldName = args[1].ToString();
genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[3].ToString();
sequenceFixedWidth = args[4].ToString();
break;
case 6: // columnName|sequenceFixedWidth|formatString
//formatString must contain [seq] and may contain [area] plus any desired text
areaLayerName = args[0].ToString();
areaLayerFieldName = args[1].ToString();
genIdAreaFieldName = args[2].ToString();
sequenceColumnName = args[3].ToString();
sequenceFixedWidth = args[4].ToString();
formatString = args[5].ToString();
break;
default: break;
}
//Find Area Layer
// FindLayerByName(areaLayerName, out areaLayer);
boolLayerOrFC = true;
if (areaLayerName.Contains("("))
{
string[] tempSplt = areaLayerName.Split('(');
areaLayerName = tempSplt[0];
areaLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, areaLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
areaLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, areaLayerName, ref boolLayerOrFC);
}
if (areaLayer == null)
{
AAState.WriteLine(" ERROR: Area Layer not found: " + areaLayerName);
break;
}
//Find Area Field
areaFieldPos = areaLayer.FeatureClass.FindField(areaLayerFieldName);
if (areaFieldPos < 0)
{
AAState.WriteLine(" ERROR: Area Layer field not found: " + areaLayerFieldName);
break;
}
//Find GenID Area Field
//genIdAreaFieldPos = areaLayer.FeatureClass.FindField(genIdAreaFieldName);
//if (genIdAreaFieldPos < 0) break;
//Perform spatial search
//sFilter = new SpatialFilterClass();
//sFilter.Geometry = (IGeometry)inFeature.ShapeCopy;
//sFilter.GeometryField = areaLayer.FeatureClass.ShapeFieldName;
//sFilter.SubFields = areaLayerFieldName;
//sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
Globals.createSpatialFilter(areaLayer, inFeature, false);
//if (boolLayerOrFC)
//{
// fCursor = areaLayer.Search(sFilter, true);
//}
//else
//{
// fCursor = areaLayer.FeatureClass.Search(sFilter, true);
//}
pFS = (IFeatureSelection)areaLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = areaLayer.Search(sFilter, true);
}
}
else
{
fCursor = areaLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
areaValue = "-9999.1";
if (sourceFeature == null)
{
AAState.WriteLine(" ERROR: Intersecting feature not found");
break;
}
else
{
while (sourceFeature != null)
{
if (sourceFeature.Class != inFeature.Class)
{
areaValue = sourceFeature.get_Value(areaFieldPos).ToString();
break;
}
if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
areaValue = sourceFeature.get_Value(areaFieldPos).ToString();
break;
}
sourceFeature = fCursor.NextFeature();
}
}
if (areaValue == "-9999.1")
{
AAState.WriteLine(" ERROR: Intersecting feature not found");
break;
}
//Check for requested zero padding of sequence number
if (sequenceFixedWidth != "")
int.TryParse(sequenceFixedWidth.ToString(), out sequencePadding);
sequenceColumnNum = AAState._gentab.FindField(sequenceColumnName);
if (sequenceColumnNum > -1)
{
qFilter = new QueryFilterClass();
qFilter.SubFields = areaLayerFieldName + "," + sequenceColumnName;
ISQLSyntax sqlSyntax = (ISQLSyntax)AAState._editor.EditWorkspace;
char[] charBuf = sqlSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix).ToCharArray();
string strSC = new string(charBuf);
switch (strSC)
{
case "":
qFilter.WhereClause = genIdAreaFieldName + " = '" + areaValue + "'";
break;
case "[":
qFilter.WhereClause = "[" + genIdAreaFieldName + "]" + " = '" + areaValue + "'";
break;
default:
qFilter.WhereClause = "\"" + genIdAreaFieldName + "\" = '" + areaValue + "'";
break;
}
//get value of first row, increment it, and return incremented value
for (int j = 0; j < 51; j++)
{
row = AAState._gentab.Update(qFilter, false).NextRow();
if (row.get_Value(sequenceColumnNum) == null)
{
sequenceValue = 0;
}
else if (row.get_Value(sequenceColumnNum).ToString() == "")
{
sequenceValue = 0;
}
else
sequenceValue = Convert.ToInt32(row.get_Value(sequenceColumnNum));
sequenceValue += 1;
sequenceValue += 1;
row.set_Value(sequenceColumnNum, sequenceValue);
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
row.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (Convert.ToInt32(row.get_Value(sequenceColumnNum)) == sequenceValue)
break;
}
if (sequenceValue == -1)
{
//TODO raise error
}
else
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString)
if (formatString == null || formatString == "" || formatString.IndexOf("[seq]") == -1)
inObject.set_Value(intFldIdxs[0], areaValue + sequenceValue.ToString("D" + sequencePadding) + sequencePostfix);
else
{
formatString = formatString.Replace("[area]", areaValue);
formatString = formatString.Replace("[seq]", sequenceValue.ToString("D" + sequencePadding));
inObject.set_Value(intFldIdxs[0], formatString);
}
else
inObject.set_Value(intFldIdxs[0], sequenceValue);
}
}
}
else
{
AAState.WriteLine(" ERROR: GENERATE_ID table is not found");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: GENERATE_ID_BY_AREA: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: GENERATE_ID_BY_AREA");
}
break;
//Modified for Release 1.2 (No longer uses ICalculator)
//Requires valid VBScript expression
//Can include string, numeric, and date fields by name in square brackets []
//Example: DateDiff("yyyy",[INSTALLDATE],Now())
case "EXPRESSION":
try
{
AAState.WriteLine(" Trying: EXPRESSION");
if (inObject != null & valData != null)
{
int intTargetFld = -1;
if (intFldIdxs.Count == 0)
{
}
else
{
intTargetFld = intFldIdxs[0];
}
newValue = valData;
for (int i = 0; i <= inObject.Fields.FieldCount; i++)
{
string strTmpFldName;
int intTmpIdx;
if (i == inObject.Fields.FieldCount)
{
testField = inObject.Fields.get_Field(intFldIdxs[0]);
strTmpFldName = "#";
intTmpIdx = intFldIdxs[0];
}
else
{
testField = inObject.Fields.get_Field(i);
strTmpFldName = testField.Name;
intTmpIdx = i;
}
int indFld = newValue.ToUpper().IndexOf("[" + strTmpFldName.ToUpper() + "]");
while (indFld >= 0)
{
AAState.WriteLine(" replace field: " + testField.Name + " with a value");
int fldLen = strTmpFldName.Length;
string tmpStr1 = newValue.Substring(0, indFld + 1);
string tmpStr2 = newValue.Substring(indFld + fldLen + 1);
newValue = tmpStr1 + "_REPLACE_VAL_" + tmpStr2;
switch (testField.Type)
{
case esriFieldType.esriFieldTypeString:
if (inObject.get_Value(intTmpIdx) == null || inObject.get_Value(intTmpIdx).ToString() == "")
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("isNull"))
{
newValue = newValue.Replace("isNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("ISNULL"))
{
newValue = newValue.Replace("ISNULL([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(intTmpIdx) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx) == DBNull.Value)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
}
// newValue = newValue.Replace("[" + testField.Name + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
break;
case esriFieldType.esriFieldTypeDate:
if (inObject.get_Value(intTmpIdx) == null || inObject.get_Value(intTmpIdx).ToString() == "" || inObject.get_Value(intTmpIdx) == DBNull.Value)
{
if (newValue.Contains("IsNull([" + "_REPLACE_VAL_" + "])"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("isNull([" + "_REPLACE_VAL_" + "])"))
{
newValue = newValue.Replace("isNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("ISNULL([" + "_REPLACE_VAL_" + "])"))
{
newValue = newValue.Replace("ISNULL([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(intTmpIdx) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else if (inObject.get_Value(intTmpIdx) == DBNull.Value)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");//"\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else if (inObject.get_Value(intTmpIdx).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "CDATE(\"" + inObject.get_Value(intTmpIdx).ToString() + "\")");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "CDATE(\"" + inObject.get_Value(intTmpIdx).ToString() + "\")");
}
}
// newValue = newValue.Replace("[" + testField.Name + "]", "CDATE(\"" + inObject.get_Value(intTmpIdx).ToString() + "\")");
break;
default:
if (inObject.get_Value(intTmpIdx) == null || inObject.get_Value(intTmpIdx).ToString() == "")
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("isNull"))
{
newValue = newValue.Replace("isNull([" + "_REPLACE_VAL_" + "])", "True");
}
else if (newValue.Contains("ISNULL"))
{
newValue = newValue.Replace("ISNULL([" + "_REPLACE_VAL_" + "])", "True");
}
else if (inObject.get_Value(intTmpIdx) == null)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx) == DBNull.Value)
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");
}
else if (inObject.get_Value(intTmpIdx).ToString() == "")
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "\"" + "\"");// "\"" + inObject.get_Value(intTmpIdx).ToString() + "\"");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", "" + inObject.get_Value(intTmpIdx).ToString() + "");
}
}
else
{
if (newValue.Contains("IsNull"))
{
newValue = newValue.Replace("IsNull([" + "_REPLACE_VAL_" + "])", "False");
}
else
{
newValue = newValue.Replace("[" + "_REPLACE_VAL_" + "]", inObject.get_Value(intTmpIdx).ToString());
}
}
// newValue = newValue.Replace("[" + testField.Name + "]", inObject.get_Value(intTmpIdx).ToString());
break;
}
indFld = newValue.ToUpper().IndexOf("[" + testField.Name.ToUpper() + "]");
}
}
//MessageBox.Show(newValue);
try
{
AAState.WriteLine(" Checking to verify there is a field to store the expression");
if (intTargetFld > -1)
{
newValue = script.Eval(newValue).ToString();
if (newValue.ToUpper() == "<Null>".ToUpper())
{
AAState.WriteLine(" Setting Null");
inObject.set_Value(intTargetFld, DBNull.Value);
}
else if (inObject.get_Value(intTargetFld).ToString() != newValue)
{
AAState.WriteLine(" Setting Value to: " + newValue.Trim());
inObject.set_Value(intTargetFld, newValue.Trim());
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: evaluating the expression for feature in " + inObject.Class.AliasName + " with OID of " + inObject.OID);
AAState.WriteLine(" " + ex.Message);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: EXPRESSION: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: EXPRESSION");
}
break;
// GUID values are calculated into text fields or into native GUID field types
// When using text field you have an optional argument (valdata) to specify the format
// N-none 32 chars, D-dash 36, B-braces 38, P-Parenthesis 38
case "GUID":
try
{
if (inObject != null)
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeGUID)
inObject.set_Value(intFldIdxs[0], System.Guid.NewGuid().ToString("B"));
else if (inObject.Fields.get_Field(intFldIdxs[0]).Type == esriFieldType.esriFieldTypeString &&
inObject.Fields.get_Field(intFldIdxs[0]).Length >= 32)
{
valData = valData.Trim();
if (valData != "N" && valData != "D" && valData != "B" && valData != "P")
if (inObject.Fields.get_Field(intFldIdxs[0]).Length >= 38)
valData = "B"; //Default to braces
else if (inObject.Fields.get_Field(intFldIdxs[0]).Length < 36)
valData = "N";
else
valData = "D";
inObject.set_Value(intFldIdxs[0], System.Guid.NewGuid().ToString(valData));
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: EXPRESSION: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: EXPRESSION");
}
break;
case "CREATE_LINKED_RECORD"://Feature Layer|Field To Copy|Field To Populate|Primary Key Field|Foreign Key Field
{
try
{
AAState.WriteLine(" Trying: CREATE_LINKED_RECORD");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 5)
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
}
else
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
if (inFeature == null)
{
AAState.WriteLine(" ERROR: The input features is null");
break;
}
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(" Getting Value Info");
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
string targetFieldName = args[2].ToString();
string sourceIDFieldName = args[3].ToString();
string targetIDFieldName = args[4].ToString();
AAState.WriteLine(" Checking values");
if (sourceFieldName != null)
{
AAState.WriteLine(" Checking Fields in Source Layer");
int fldValToCopyIdx = inObject.Fields.FindField(sourceFieldName);
int fldIDToCopyIdx = inObject.Fields.FindField(sourceIDFieldName);
if (fldValToCopyIdx > -1 && fldIDToCopyIdx > -1)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
// Get layer
AAState.WriteLine(" Checking for table to populate");
bool FCorLayerSource = true;
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref FCorLayerSource);
if (sourceLayer != null)
{
}
else
{
ITable pTable = Globals.FindTable(AAState._editor.Map, sourceLayerName);
if (pTable != null)
{
int fldValToPopIdx = pTable.Fields.FindField(targetFieldName);
int fldIDToPopIdx = pTable.Fields.FindField(targetIDFieldName);
if (fldValToPopIdx > -1 && fldIDToPopIdx > -1)
{
AAState.WriteLine(" Trying to create a row in the target table");
IRow pNewRow = pTable.CreateRow();
AAState.WriteLine(" Row Created");
AAState.WriteLine(" Trying to Copy ID");
try
{
pNewRow.set_Value(fldIDToPopIdx, inObject.get_Value(fldIDToCopyIdx));
}
catch
{
AAState.WriteLine(" ERROR: Could not Copy: " + inObject.get_Value(fldIDToCopyIdx) + " to field: " + targetIDFieldName);
}
AAState.WriteLine(" ID successfully copied");
AAState.WriteLine(" Trying to Copy Value");
try
{
pNewRow.set_Value(fldValToPopIdx, inObject.get_Value(fldValToCopyIdx));
}
catch
{
AAState.WriteLine(" ERROR: Could not Copy: " + inObject.get_Value(fldValToCopyIdx) + " to field: " + targetFieldName);
}
//AAState.WriteLine(" Value successfully copied");
////}
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//pNewRow.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
if (NewFeatureList == null)
{
NewFeatureList = new List<IObject>();
}
IObject featobj = pNewRow as IObject;
if (featobj != null)
{
NewFeatureList.Add(featobj);
}
//featobj.Store();
AAState.WriteLine(" Row successfully stored");
}
else
{
AAState.WriteLine(" ERROR: ID or Field to populate was not found");
}
}
else
{
AAState.WriteLine(" ERROR: Table to populate not found: " + sourceLayerName);
}
}
}
}
}
else
{
AAState.WriteLine(" ERROR: ID or Field to Copy was not found");
}
//if ((!found) && (inObject.Fields.get_Field(intFldIdxs[0]).IsNullable))
//{
// inObject.set_Value(intFldIdxs[0], null);
//}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: CREATE_LINKED_RECORD" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: CREATE_LINKED_RECORD");
// intFldIdxs[0] = -1;
}
break;
}
case "UPDATE_INTERSECTING_FEATURE"://Intersected Feature|FieldIntersectingFeatureToChange|FromFieldinModifiedFeature
{
try
{
IFeatureCursor fLocalCursor = null;
IFeature sourceFeatureLocal = null;
AAState.WriteLine(" Trying: UPDATE_INTERSECTING_FEATURE");
if (!String.IsNullOrEmpty(valData))
{
args = valData.Split('|');
if (args.Length != 3)
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
}
else
{
AAState.WriteLine(" ERROR: Format of valdata incorrect");
break;
}
if (inFeature == null)
{
AAState.WriteLine(" ERROR: The input features is null");
break;
}
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(" Getting Value Info");
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
string targetFieldName = args[2].ToString();
AAState.WriteLine(" Checking values");
if (sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
if (Globals.IsEditable(ref sourceLayer, ref AAState._editor))
{
if (inObject.Class.ObjectClassID != sourceLayer.FeatureClass.ObjectClassID)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
//sFilter = new SpatialFilterClass();
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
int fldIdx = inFeature.Fields.FindField(targetFieldName);
AAState.WriteLine(" " + targetFieldName + " at index " + fldIdx);
string test = targetFieldName;
if (fldIdx > -1)
{
test = inFeature.get_Value(fldIdx).ToString();
AAState.WriteLine(" Value Found " + test);
}
AAState.WriteLine(" Value used " + test);
//if (boolLayerOrFC)
//{
// fLocalCursor = sourceLayer.Search(sFilter, false);
//}
//else
//{
// fLocalCursor = sourceLayer.FeatureClass.Search(sFilter, false);
//}
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, false, out cCurs);
fLocalCursor = cCurs as IFeatureCursor;
}
else
{
fLocalCursor = sourceLayer.Search(sFilter, false);
}
}
else
{
fLocalCursor = sourceLayer.FeatureClass.Search(sFilter, false);
}
while ((sourceFeatureLocal = fLocalCursor.NextFeature()) != null)
{
try
{
if (sourceFeatureLocal.Class.ObjectClassID != inFeature.Class.ObjectClassID)
{
if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeString)
{
sourceFeatureLocal.set_Value(sourceField, test);
//}
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
////AAState.indent = AAState.indent.Substring(0, AAState.indent.Length-13);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
//break;
}
else
{
if (Globals.IsNumeric(test))
{
if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSmallInteger ||
sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeInteger)
{
sourceFeatureLocal.set_Value(sourceField, Convert.ToInt32(test));
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
//break;
}
else if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeDouble ||
sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSingle)
{
sourceFeatureLocal.set_Value(sourceField, Convert.ToDouble(test));
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
//break;
}
else
{
sourceFeatureLocal.set_Value(sourceField, test as object);
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
// break;
}
}
else
{
sourceFeatureLocal.set_Value(sourceField, test as object);
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
// break;
}
}
}
else if (sourceFeatureLocal.Class == inFeature.Class && sourceFeatureLocal.OID != inFeature.OID)
{
if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeString)
{
sourceFeatureLocal.set_Value(sourceField, test);
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
//break;
}
else
{
if (Globals.IsNumeric(test))
{
if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSmallInteger ||
sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeInteger)
{
sourceFeatureLocal.set_Value(sourceField, Convert.ToInt32(test));
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
//break;
}
else if (sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeDouble ||
sourceFeatureLocal.Fields.get_Field(sourceField).Type == esriFieldType.esriFieldTypeSingle)
{
sourceFeatureLocal.set_Value(sourceField, Convert.ToDouble(test));
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
// break;
}
else
{
sourceFeatureLocal.set_Value(sourceField, test as object);
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
//break;
}
}
else
{
sourceFeatureLocal.set_Value(sourceField, test as object);
//AAState.WriteLine(" INFO: New feature being store, AA rules will fire on it now");
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.indent = AAState.indent + " ";
//string rowFiltPre = AAState._dv.RowFilter;
//sourceFeatureLocal.Store();
//AAState._dv.RowFilter = rowFiltPre;
//AAState.indent = AAState.indent.Substring(0, AAState.indent.Length - " ".Length);
//AAState.WriteLine(" _|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_");
//AAState.WriteLine(" INFO: New Feature Complete");
//AAState.changeFeature -= OnChangeFeature;
//AAState.createFeature -= OnCreateFeature;
//sourceFeatureLocal.Store();
//AAState.changeFeature += OnChangeFeature;
//AAState.createFeature += OnCreateFeature;
if (ChangeFeatureList == null)
{
ChangeFeatureList = new List<IObject>();
}
ChangeFeatureList.Add(sourceFeatureLocal);
found = true;
//break;
}
}
}
}
catch
{
AAState.WriteLine(" ERROR setting value");
}
finally
{
}
//if (found)
//{
// break;
//}
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer is not editable: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer not found: " + sourceLayerName);
}
}
}
if (found)
{
break;
}
//if ((!found) && (inObject.Fields.get_Field(intFldIdxs[0]).IsNullable))
//{
// inObject.set_Value(intFldIdxs[0], null);
//}
}
fLocalCursor = null;
sourceFeatureLocal = null;
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: UPDATE_INTERSECTING_FEATURE" + Environment.NewLine + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: UPDATE_INTERSECTING_FEATURE");
// intFldIdxs[0] = -1;
}
break;
}
case "MULTI_FIELD_INTERSECT":
try
{
AAState.WriteLine(" Trying: MULTI_FIELD_INTERSECT");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int popFldIdx = 0;
if (args.GetLength(0) > 2)
{
AAState.WriteLine(" Parsing Valueinfo");
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
string[] fieldsToPop = args[2].ToString().Split(',');
if (args.GetLength(0) == 4)
{
AAState.WriteLine(" Search distance specified");
if (Globals.IsDouble(args[3]))
{
searchDistance = Convert.ToDouble(args[3]);
}
else
{
searchDistance = 0.0;
}
}
else
{
searchDistance = 0.0;
}
if (sourceFieldName != null)
{
AAState.WriteLine(" Looping Through Layers");
for (int i = 0; i < sourceLayerNames.Length; i++)
{
if (fieldsToPop.Length == popFldIdx)
break;
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
//sFilter = new SpatialFilterClass();
//if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPoint)
//{
//searchEnvelope = Globals.CalcSearchExtent(sourceLayer, inFeature, searchDistance);
// sFilter.Geometry = searchEnvelope;
//}
//else
//{
// sFilter.Geometry = inFeature.ShapeCopy;
//}
//sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
//sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
//if (boolLayerOrFC)
//{
// fCursor = sourceLayer.Search(sFilter, true);
//}
//else
//{
// fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
//}
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
while ((sourceFeature = fCursor.NextFeature()) != null)
{
if (sourceFeature.Class != inFeature.Class)
{
if (fieldsToPop.Length == popFldIdx)
break;
string test = sourceFeature.get_Value(sourceField).ToString();
int tempFieldNum = inObject.Fields.FindField(fieldsToPop[popFldIdx]);
popFldIdx++;
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, sourceFeature.get_Value(sourceField));
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
if (fieldsToPop.Length == popFldIdx)
break;
string test = sourceFeature.get_Value(sourceField).ToString();
int tempFieldNum = inObject.Fields.FindField(fieldsToPop[popFldIdx]);
popFldIdx++;
if (tempFieldNum > -1)
{
inObject.set_Value(tempFieldNum, sourceFeature.get_Value(sourceField));
}
}
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Datasource is invalid: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer not found: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer string is empty");
}
}
}
else
{
AAState.WriteLine(" ERROR: Field name is invalid");
}
}
else
{
AAState.WriteLine(" ERROR: Invalid Value method definition");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: MULTI_FIELD_INTERSECT: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: MULTI_FIELD_INTERSECT");
}
break;
case "INTERSECT_STATS":
try
{
AAState.WriteLine(" Trying: INTERSECT_STATS");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int AverageCount = 0;
if (args.GetLength(0) > 2)
{
AAState.WriteLine(" Parsing Valueinfo");
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
string statType = args[2].ToString();
if (args.GetLength(0) == 4)
{
AAState.WriteLine(" Search distance specified");
if (Globals.IsDouble(args[3]))
searchDistance = Convert.ToDouble(args[3]);
else
searchDistance = 0.0;
}
else
{
searchDistance = 0.0;
}
double result = -999999.1;
string textRes = "";
if (sourceFieldName != null)
{
AAState.WriteLine(" Looping Through Layers");
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer != null)
{
if (sourceLayer.FeatureClass != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
//if (boolLayerOrFC)
//{
// fCursor = sourceLayer.Search(sFilter, true);
//}
//else
//{
// fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
//}
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
if (sourceFeature.Class != inFeature.Class)
{
string test = sourceFeature.get_Value(sourceField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" ERROR/WARNING: Non numeric value returned: " + test);
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
string test = sourceFeature.get_Value(sourceField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" ERROR/WARNING: Non numeric value returned: " + test);
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
sourceFeature = fCursor.NextFeature();
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Datasource is invalid: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer not found: " + sourceLayerName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer string is empty");
}
}
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Value was not set on feature: " + ex.Message);
}
}
else
{
AAState.WriteLine(" ERROR: Field name is invalid");
}
}
else
{
AAState.WriteLine(" ERROR: Invalid Value method definition");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECT_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECT_STATS");
}
break;
case "FEATURE_STATS":
try
{
AAState.WriteLine(" Trying: FEATURE_STATS");
if (inFeature != null & valData != null)
{
sourceFieldName = "";
sourceField = -1;
found = false;
//LayerToIntersect|Field To Elevate
// Parse arguments
args = valData.Split('|');
int AverageCount = 0;
if (args.GetLength(0) > 1)
{
AAState.WriteLine(" Parsing Valueinfo");
string[] sourceFieldNames = args[0].ToString().Split(',');
string statType = args[1].ToString();
double result = -999999.1;
string textRes = "";
if (sourceFieldNames != null)
{
AAState.WriteLine(" Looping Through Fields");
for (int i = 0; i < sourceFieldNames.Length; i++)
{
sourceFieldName = sourceFieldNames[i].ToString();
if (sourceFieldName != "")
{
sourceField = inObject.Fields.FindField(sourceFieldName);
if (sourceField > -1)
{
string test = inObject.get_Value(sourceField).ToString();
if (Globals.IsNumeric(test))
{
double valToTest = Convert.ToDouble(test);
if (result == -999999.1)
{
result = valToTest;
}
else
{
switch (statType.ToUpper())
{
case "MAX":
if (result < valToTest)
{
result = valToTest;
}
break;
case "MIN":
if (result > valToTest)
{
result = valToTest;
}
break;
case "SUM":
result += valToTest;
break;
case "AVERAGE":
result += valToTest;
AverageCount++;
break;
case "MEAN":
result += valToTest;
AverageCount++;
break;
case "CONCAT":
if (textRes.Contains(valToTest.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + valToTest.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += valToTest.ToString();
}
else
{
textRes += ConcatDelim + valToTest.ToString();
}
}
break;
default:
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
else
{
switch (statType.ToUpper())
{
case "CONCAT":
if (textRes.Contains(test.ToString() + ConcatDelim))
{
}
else if (textRes.Contains(ConcatDelim + test.ToString()))
{
}
else
{
if (textRes == "")
{
textRes += test;
}
else
{
textRes += ConcatDelim + test;
}
}
break;
default:
AAState.WriteLine(" ERROR/WARNING: Non numeric value returned: " + test);
AAState.WriteLine(" ERROR: Unsupported stat type: " + test);
break;
}
}
}
}
}
try
{
if (textRes != "")
{
inObject.set_Value(intFldIdxs[0], textRes);
}
else if (result != -999999.1)
{
if (AverageCount != 0)
{
result = result / AverageCount;
}
inObject.set_Value(intFldIdxs[0], result);
}
else
{
IField field = inObject.Fields.get_Field(intFldIdxs[0]);
object newval = field.DefaultValue;
if (newval == null)
{
if (field.IsNullable)
{
inObject.set_Value(intFldIdxs[0], null);
}
}
else
{
inObject.set_Value(intFldIdxs[0], newval);
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Value was not set on feature: " + ex.Message);
}
}
else
{
AAState.WriteLine(" ERROR: Field name is invalid");
}
}
else
{
AAState.WriteLine(" ERROR: Invalid Value method definition");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: FEATURE_STATS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: FEATURE_STATS");
}
break;
case "INTERSECTING_EDGE":
try
{
if (valData == null) break;
args = valData.Split('|');
switch (args.GetLength(0))
{
case 1:
sourceFieldName = args[0].ToString();
break;
case 2:
sourceFieldName = args[1].ToString();
break;
default: break;
}
AAState.WriteLine(" Trying: INTERSECTING_EDGE");
if (inFeature != null)
{
netFeat = inFeature as INetworkFeature;
if (netFeat != null)
{
AAState.WriteLine(" Feature is a network feature");
if (inFeature.FeatureType == esriFeatureType.esriFTComplexJunction || inFeature.FeatureType == esriFeatureType.esriFTSimpleJunction)
{
AAState.WriteLine(" Feature is a junction feature");
iJuncFeat = (IJunctionFeature)netFeat;
ISimpleJunctionFeature iSJunc = iJuncFeat as ISimpleJunctionFeature;
if (iSJunc == null)
break;
AAState.WriteLine(" Edge Count: " + iSJunc.EdgeFeatureCount);
if (iSJunc.EdgeFeatureCount <= 0)
break;
if (iSJunc.EdgeFeatureCount > 0)
{
for (int i = 0; i < iSJunc.EdgeFeatureCount; i++)
{
iEdgeFeat = iSJunc.get_EdgeFeature(i);
try
{
IRow pRow = iEdgeFeat as IRow;
// verify that field (in junction) to copy exists
AAState.WriteLine(" Getting Field From Edge");
juncField = pRow.Fields.FindField(sourceFieldName);
string test = pRow.get_Value(juncField).ToString();
AAState.WriteLine(" Attempting to store: " + test);
inObject.set_Value(intFldIdxs[0], test);
continue;
}
catch
{
}
}//end loop
try
{
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: Value was not set on feature: " + ex.Message);
}
}
else
{
AAState.WriteLine(" No Connected Edges Found");
}
}
else
{
AAState.WriteLine(" not an junction feature");
}
}
else
{
AAState.WriteLine(" Not a Geometric Network Feature");
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_EDGE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_EDGE");
}
break;
case "INTERSECTING_FEATURE":
try
{
AAState.WriteLine(" Trying: INTERSECTING_FEATURE");
if (inFeature != null & valData != null)
{
AAState.WriteLine(" Starting to process rule");
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
found = false;
AAState.WriteLine(" Value Info is: " + valData);
// Parse arguments
args = valData.Split('|');
//if (args.GetLength(0) >= 2)
if (args.Length >= 2)
{
AAState.intersectOptions strOpt = AAState.intersectOptions.First;
switch (args.Length)
{
case 2:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
break;
case 3:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
switch (args[2].ToString().ToUpper())
{
case "PROMPT":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "P":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "CENTROID":
strOpt = AAState.intersectOptions.Centroid;
break;
case "C":
strOpt = AAState.intersectOptions.Centroid;
break;
case "F":
strOpt = AAState.intersectOptions.First;
break;
case "FIRST":
strOpt = AAState.intersectOptions.First;
break;
}
break;
default: break;
}
if (sourceFieldName != null)
{
List<Globals.OptionsToPresent> pFoundFeat = new List<Globals.OptionsToPresent>();
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
// Get layer
if (sourceLayer != null)
{
AAState.WriteLine(" Layer Found: " + sourceLayer.Name);
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
AAState.WriteLine(" " + sourceFieldName + ": at " + sourceField);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, strOpt == AAState.intersectOptions.Centroid);
if (sFilter == null)
{
AAState.WriteLine(" Filter is null, this will cause an error");
continue;
}
//if (boolLayerOrFC)
//{
// fCursor = sourceLayer.Search(sFilter, true);
//}
//else
//{
// fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
//}
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
AAState.WriteLine(" Searching on Layer");
if (pFS.SelectionSet.Count > 0)
{
AAState.WriteLine(" Searching on Selection Set");
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
AAState.WriteLine(" Cursor created");
}
else
{
AAState.WriteLine(" No Selected Features");
fCursor = sourceLayer.Search(sFilter, true);
AAState.WriteLine(" Cursor created");
}
}
else
{
AAState.WriteLine(" Searching on feature Class");
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
AAState.WriteLine(" Cursor created");
}
if (fCursor == null)
{
AAState.WriteLine(" Cursor is null");
continue;
}
AAState.WriteLine(" Starring Loop of found features");
while ((sourceFeature = fCursor.NextFeature()) != null)
{
AAState.WriteLine(" Checking Class");
if (sourceFeature.Class != inFeature.Class)
{
AAState.WriteLine(" Different FCs");
if (strOpt == AAState.intersectOptions.PromptMulti)
{
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(sourceFeature.Fields.FindField(sourceLayer.DisplayField)).ToString();
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display;
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID;
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
}
else
{
string test = sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(" Setting Value: " + test);
inObject.set_Value(intFldIdxs[0], sourceFeature.get_Value(sourceField));
AAState.WriteLine(" Value Set");
found = true;
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
AAState.WriteLine(" Same FC");
if (strOpt == AAState.intersectOptions.PromptMulti)
{
//pFoundFeat.Add(sourceFeature.OID.ToString());
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(sourceFeature.Fields.FindField(sourceLayer.DisplayField)).ToString();
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display;
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID;
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
}
else
{
string test = sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(" Setting Value: " + test);
inObject.set_Value(intFldIdxs[0], sourceFeature.get_Value(sourceField));
AAState.WriteLine(" Value Set");
found = true;
}
}
if (found == true)
break;
}
if (found == false && AAState._CheckEnvelope && pFoundFeat.Count == 0)
{
sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelEnvelopeIntersects;
// sFilter.SpatialRelDescription = "T*T***T*T";
//if (boolLayerOrFC)
//{
// fCursor = sourceLayer.Search(sFilter, true);
//}
//else
//{
// fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
//}
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
sourceFeature = fCursor.NextFeature();
while (sourceFeature != null)
{
if (strOpt == AAState.intersectOptions.PromptMulti)
{
Globals.OptionsToPresent pOp = new Globals.OptionsToPresent();
pOp.Display = sourceFeature.get_Value(sourceFeature.Fields.FindField(sourceLayer.DisplayField)).ToString();
if (pOp.Display.Trim() != "")
{
pOp.Display = sourceLayer.Name + ": " + pOp.Display;
}
else
{
pOp.Display = sourceLayer.Name + ": " + sourceFeature.OID;
}
pOp.OID = sourceFeature.OID;
pOp.LayerName = sourceLayer.Name;
pFoundFeat.Add(pOp);
//pFoundFeat.Add(sourceFeature.OID.ToString());
}
else
{
if (found)
{
break;
}
string test = sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(" Setting Value: " + test);
inObject.set_Value(intFldIdxs[0], sourceFeature.get_Value(sourceField));
AAState.WriteLine(" Value Set");
found = true;
}
sourceFeature = fCursor.NextFeature();
}
}
if (found)
{
break;
}
}
else
{
AAState.WriteLine(" ERROR: Source field not found: " + sourceFieldName);
}
}
else
{
AAState.WriteLine(" ERROR/WARNING: Source Layer not found: " + sourceLayerName);
}
}
}
if (pFoundFeat.Count > 0 && strOpt == AAState.intersectOptions.PromptMulti)
{
Globals.OptionsToPresent strRetVal = Globals.showOptionsForm(pFoundFeat, "Select A feature", "Select A feature", ComboBoxStyle.DropDownList);
if (strRetVal != null)
{
sourceFeature = sourceLayer.FeatureClass.GetFeature(strRetVal.OID);
string test = sourceFeature.get_Value(sourceField).ToString();
AAState.WriteLine(" Setting Value: " + test);
inObject.set_Value(intFldIdxs[0], sourceFeature.get_Value(sourceField));
AAState.WriteLine(" Value Set");
found = true;
}
}
//if (!found)
//{
// //IField field = inObject.Fields.get_Field(intFldIdxs[0]);
// //object newval = field.DefaultValue;
// //if (newval == null)
// //{
// // if (field.IsNullable)
// // {
// // AAState.WriteLine(" Setting Value default null value");
// // inObject.set_Value(intFldIdxs[0], null);
// // AAState.WriteLine(" Value Set");
// // }
// //}
// //else
// //{
// // AAState.WriteLine(" Setting Value default value");
// // inObject.set_Value(intFldIdxs[0], newval);
// // AAState.WriteLine(" Value Set");
// //}
//}
}
else
{
AAState.WriteLine(" ERROR: INTERSECTING_FEATURE: source field name is null");
}
}
else
{
AAState.WriteLine(" ERROR: INTERSECTING_FEATURE: Value Info is not in the expected format");
}
}
else
{
AAState.WriteLine(" ERROR: INTERSECTING_FEATURE: Input Feature or Value Info is null");
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_FEATURE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_FEATURE");
}
break;
case "INTERSECTING_RASTER":
try
{
AAState.WriteLine(" Trying: INTERSECTING_RASTER");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
formatString = "";
found = false;
// Parse arguments
args = valData.Split('|');
if (args.Length < 1) break;
switch (args.Length)
{
case 1:
sourceLayerNames = args[0].ToString().Split(',');
break;
case 2:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
break;
default: break;
}
// Get layer
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
IPoint pLoc = Globals.GetGeomCenter(inFeature)[0];
if (pLoc != null)
{
string cellVal = GetCellValue(sourceLayerName, pLoc, AAState._editor.Map);// Globals.GetCellValue(sourceLayerName, pLoc, _editor.Map);
AAState.WriteLine(" ERROR/WARING: No cell value or raster was found: " + sourceLayerName);
if (cellVal != null && cellVal != "" && cellVal != "No Raster")
{
if (formatString == null || formatString == "" || (inObject.Fields.get_Field(intFldIdxs[0]).Type != esriFieldType.esriFieldTypeString))
{
inObject.set_Value(intFldIdxs[0], cellVal);
found = true;
break;
}
else
{
// formatString = formatString.Replace("[value]",cellVal);
formatString = formatString + cellVal;
inObject.set_Value(intFldIdxs[0], formatString);
found = true;
break;
}
}
}
}
if (!(found) && inObject.Fields.get_Field(intFldIdxs[0]).IsNullable)
inObject.set_Value(intFldIdxs[0], null);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_RASTER: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_RASTER");
}
break;
case "INTERSECTING_LAYER_DETAILS":
try
{
AAState.WriteLine(" Trying: INTERSECTING_LAYER_DETAILS");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
formatString = "";
found = false;
List<string> matchPattern = null;
// Parse arguments
args = valData.Split('|');
if (args.Length >= 1)
{
AAState.intersectOptions strOpt = AAState.intersectOptions.First;
switch (args.Length)
{
case 1:
sourceLayerNames = args[0].ToString().Split(',');
formatString = "P";
break;
case 2:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
break;
case 3:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
switch (args[2].ToString().ToUpper())
{
case "PROMPT":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "P":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "CENTROID":
strOpt = AAState.intersectOptions.Centroid;
break;
case "C":
strOpt = AAState.intersectOptions.Centroid;
break;
case "F":
strOpt = AAState.intersectOptions.First;
break;
case "FIRST":
strOpt = AAState.intersectOptions.First;
break;
}
break;
case 4:
sourceLayerNames = args[0].ToString().Split(',');
formatString = args[1].ToString();
switch (args[2].ToString().ToUpper())
{
case "PROMPT":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "P":
strOpt = AAState.intersectOptions.PromptMulti;
break;
case "CENTROID":
strOpt = AAState.intersectOptions.Centroid;
break;
case "C":
strOpt = AAState.intersectOptions.Centroid;
break;
case "F":
strOpt = AAState.intersectOptions.First;
break;
case "FIRST":
strOpt = AAState.intersectOptions.First;
break;
}
matchPattern = new List<string>(args[3].ToString().Split(','));
//matchPattern = .ToList<string>();
break;
default: break;
}
List<Globals.OptionsToPresent> strFiles = new List<Globals.OptionsToPresent>();
// Get layer
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
//AAState.WriteLine(" Getting Features Centeroid");
//IPoint pLoc = Globals.GetGeomCenter(inFeature);
IGeometry pGeo = inFeature.ShapeCopy;
List<IGeometry> pGeos = new List<IGeometry>();
if (pGeo != null)
{
if (strOpt == AAState.intersectOptions.Centroid)
{
List<IPoint> pGeoPnts = Globals.GetGeomCenter(pGeo);
pGeos = pGeoPnts.ConvertAll(new Converter<IPoint, IGeometry>(Globals.PointToGeometry));
}
else
{
pGeos.Add(pGeo);
}
// AAState.WriteLine(" Centroid Found");
AAState.WriteLine(" Getting list of " + sourceLayerName + " Layers");
IEnumLayer pEnum = Globals.GetLayers(AAState._editor.Map, sourceLayerName);
if (pEnum != null)
{
AAState.WriteLine(" List retrieved of " + sourceLayerName + " Layers");
AAState.WriteLine(" Starting Loop");
ILayer pLay = pEnum.Next();
//ISpatialFilter pSpatFilt;
while (pLay != null)
{
intersectLayerDetailsFunctions(pLay, pGeos, strOpt, ref found, ref strFiles, ref inObject, intFldIdxs[0], matchPattern);
if (found)
{
AAState.WriteLine(" Exiting Layer Loop");
break;
}
pLay = pEnum.Next();
}
pLay = null;
pEnum = null;
}
else
{
bool FCorLayerTemp = true;
ILayer pLay = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref FCorLayerTemp);
if (pLay != null)
{
intersectLayerDetailsFunctions(pLay, pGeos, strOpt, ref found, ref strFiles, ref inObject, intFldIdxs[0], matchPattern);
}
pLay = null;
}
if (pEnum != null)
Marshal.ReleaseComObject(pEnum);
pEnum = null;
}
else
{
AAState.WriteLine(" ERROR: Geo not Found");
}
if (found)
{
AAState.WriteLine(" Exiting Layer Loop");
break;
}
pGeo = null;
pGeos = null;
}
if (strOpt == AAState.intersectOptions.PromptMulti && strFiles.Count > 0)
{
Globals.OptionsToPresent strRetVal = Globals.showOptionsForm(strFiles, "Select a intersect layer", "Select a intersect layer", ComboBoxStyle.DropDownList);
if (strRetVal != null)
{
try
{
inObject.set_Value(intFldIdxs[0], strRetVal.Display);
}
catch
{
MessageBox.Show("Error Setting the value in the Intersecting_Layer_Details");
}
found = true;
}
}
}
else
{
AAState.WriteLine(" ERROR: Value info is not correct");
}
//if (!(found) && inObject.Fields.get_Field(intFldIdxs[0]).IsNullable)
// inObject.set_Value(intFldIdxs[0], null);
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_LAYER_DETAILS: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_LAYER_DETAILS");
}
break;
case "INTERSECTING_FEATURE_DISTANCE":
try
{
AAState.WriteLine(" Trying: INTERSECTING_FEATURE_DISTANCE");
if (inFeature != null & valData != null)
{
sourceLayerName = "";
sourceFieldName = "";
sourceField = -1;
// Parse arguments
args = valData.Split('|');
if (args.GetLength(0) >= 2)
{
// sourceLayerName = args[0].ToString();
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
}
// Get layer
if (sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
sourceLayerName = args[i].ToString();
if (i == 0)
i++;
boolLayerOrFC = true;
if (sourceLayerName.Contains("("))
{
string[] tempSplt = sourceLayerName.Split('(');
sourceLayerName = tempSplt[0];
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
if (tempSplt[1].ToUpper().Contains("LAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURELAYER)"))
{
boolLayerOrFC = true;
}
else if (tempSplt[1].ToUpper().Contains("FEATURECLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("CLASS)"))
{
boolLayerOrFC = false;
}
else if (tempSplt[1].ToUpper().Contains("FEATURE)"))
{
boolLayerOrFC = false;
}
else
{
boolLayerOrFC = true;
}
}
else
{
sourceLayer = (IFeatureLayer)Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref boolLayerOrFC);
}
if (sourceLayer == null)
{
AAState.WriteLine(" ERROR/WARNING: " + sourceLayerName + " was not found");
continue;
}
IFeatureClass iFC = inFeature.Class as IFeatureClass;
if (sourceLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
AAState.WriteLine(" ERROR: " + sourceLayer + " is a polygon layer");
break;
}
if (sourceLayer != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
if (pFS.SelectionSet.Count > 0)
{
pFS.SelectionSet.Search(sFilter, true, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, true);
}
}
else
{
fCursor = sourceLayer.FeatureClass.Search(sFilter, true);
}
while ((sourceFeature = fCursor.NextFeature()) != null)
{
if (sourceFeature.Class != inFeature.Class)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
IPoint snapPnt = null;
double dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
snapPnt = null;
string strUnit = Globals.GetSpatRefUnitName(Globals.GetLayersCoordinateSystem(sourceLayer.FeatureClass), true);
if (strUnit == "Foot" && dAlong != 1)
{
strUnit = "Feet";
}
else if (strUnit == "Meter" && dAlong != 1)
{
strUnit = "Meters";
}
string strDis = dAlong + " " + strUnit + " along " + sourceLayer.Name + " with " + sourceLayer.FeatureClass.Fields.get_Field(sourceField).AliasName + " of " + sourceFeature.get_Value(sourceField);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong + " " + strUnit + ": " + sourceFeature.get_Value(sourceField);
AAState.WriteLine(" Text is to long, defaulting to length along: " + strDis);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
else
{
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
else
{
strDis = dAlong.ToString();
AAState.WriteLine(" Text is to long, defaulting to length along: " + strDis);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
else
{
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
}
else
{
AAState.WriteLine(" Value set to: " + strDis);
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
IPoint pIntPnt;
if (inFeature.Shape.GeometryType == esriGeometryType.esriGeometryPolyline)
{
pIntPnt = Globals.GetIntersection(inFeature.ShapeCopy, sourceFeature.ShapeCopy as IPolyline) as IPoint;
}
else
pIntPnt = inFeature.ShapeCopy as IPoint;
IPoint snapPnt = null;
double dAlong = Globals.PointDistanceOnLine(pIntPnt, sourceFeature.Shape as IPolyline, 2, out snapPnt);
snapPnt = null;
string strUnit = Globals.GetSpatRefUnitName(Globals.GetLayersCoordinateSystem(sourceLayer.FeatureClass), true);
if (strUnit == "Foot" && dAlong != 1)
{
strUnit = "Feet";
}
else if (strUnit == "Meter" && dAlong != 1)
{
strUnit = "Meters";
}
string strDis = dAlong + " " + strUnit + " along " + sourceLayer.Name + " with " + sourceLayer.FeatureClass.Fields.get_Field(sourceField).AliasName + " of " + sourceFeature.get_Value(sourceField);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong + " " + strUnit + ": " + sourceFeature.get_Value(sourceField);
AAState.WriteLine(" Text is to long, defaulting to length along: " + strDis);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
else
{
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
else
{
strDis = dAlong.ToString();
AAState.WriteLine(" Text is to long, defaulting to length along: " + strDis);
if (inObject.Fields.get_Field(intFldIdxs[0]).Length < strDis.Length - 1)
{
strDis = dAlong.ToString();
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
else
{
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
}
else
{
AAState.WriteLine(" Value set to: " + strDis);
inObject.set_Value(intFldIdxs[0], strDis);
break;
}
}
}
//else if (inObject.Fields.get_Field(intFldIdxs[0]).IsNullable)
// inObject.set_Value(intFldIdxs[0], null);
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayer + ": field: " + sourceFieldName + " was not found");
}
}
else { }
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: INTERSECTING_FEATURE_DISTANCE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: INTERSECTING_FEATURE_DISTANCE");
}
break;
//Release: 1.2
//New Dynamic Value Method: NEARSET_FEATURE - similiar to INTERSECTING_FEATURE but requires a search distance.
case "NEAREST_FEATURE":
try
{
AAState.WriteLine(" Trying: NEAREST_FEATURE");
if (inFeature != null & valData != null)
{
string sourceMatField = "";
string targetMatField = "";
sourceLayerName = "";
sourceFieldName = "";
searchDistance = 0;
found = false;
// Parse arguments
args = valData.Split('|');
switch (args.Length)
{
case 2:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
break;
case 3:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
Double.TryParse(args[2], out searchDistance);
break;
case 4:
AAState.WriteLine(" ERROR: Incorrect value method");
break;
case 5:
sourceLayerNames = args[0].ToString().Split(',');
sourceFieldName = args[1].ToString();
Double.TryParse(args[2], out searchDistance);
sourceMatField = args[3].ToString();
targetMatField = args[4].ToString();
break;
default:
AAState.WriteLine(" ERROR: Incorrect value method");
break;
}
if (sourceLayerNames.Length > 0 & sourceFieldName != null)
{
for (int i = 0; i < sourceLayerNames.Length; i++)
{
sourceLayerName = sourceLayerNames[i].ToString();
if (sourceLayerName != "")
{
bool FCorLayerSource = true;
sourceLayer = Globals.FindLayer(AAState._editor.Map, sourceLayerName, ref FCorLayerSource) as IFeatureLayer;
if (sourceLayer != null)
{
sourceField = sourceLayer.FeatureClass.FindField(sourceFieldName);
if (sourceField > -1)
{
//sFilter = new SpatialFilterClass();
//if (searchDistance > 0)
//{
// searchEnvelope = inFeature.ShapeCopy.Envelope;
// searchEnvelope.Expand(searchDistance, searchDistance, false);
// sFilter.Geometry = searchEnvelope;
//}
//else
// sFilter.Geometry = inFeature.ShapeCopy;
//sFilter.GeometryField = sourceLayer.FeatureClass.ShapeFieldName;
//sFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
sFilter = Globals.createSpatialFilter(sourceLayer, inFeature, searchDistance, false);
pFS = (IFeatureSelection)sourceLayer;
if (boolLayerOrFC)
{
AAState.WriteLine(" Searching the layer");
if (pFS.SelectionSet.Count > 0)
{
AAState.WriteLine(" There is a seleciton set, only checking selected features");
pFS.SelectionSet.Search(sFilter, false, out cCurs);
fCursor = cCurs as IFeatureCursor;
}
else
{
fCursor = sourceLayer.Search(sFilter, false);
}
}
else
{
AAState.WriteLine(" Searching the feature class");
fCursor = sourceLayer.FeatureClass.Search(sFilter, false);
}
nearestFeature = null;
proxOp = (IProximityOperator)inFeature.ShapeCopy;
lastDistance = searchDistance;
while ((sourceFeature = fCursor.NextFeature()) != null)
{
if (sourceFeature.Class != inFeature.Class)
{
AAState.WriteLine(" Feature Classes are different");
if (targetMatField == "" && sourceMatField == "")
{
AAState.WriteLine(" No matching fields specified");
try
{
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
catch
{
MessageBox.Show("Error in the Nearest Feature - Proximity Operator. This may be caused by corrupt data in the layer, Please run Check/Repair Geometry GP tool on your layer");
return false;
}
}
else
{
AAState.WriteLine(" matching fields specified");
int idxTargetFld = Globals.GetFieldIndex(sourceLayer, targetMatField);
int idxSourceFld = Globals.GetFieldIndex(inObject.Fields, sourceMatField);
if (idxSourceFld >= 0 && idxTargetFld >= 0)
{
AAState.WriteLine(" Fields Found");
if (inObject.get_Value(idxSourceFld).ToString() == sourceFeature.get_Value(idxTargetFld).ToString())
{
AAState.WriteLine(" Values Match");
//distance = proxOp.ReturnDistance(sourceFeature.Shape);
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
else
{
AAState.WriteLine(" Values does not Match: " + inObject.get_Value(idxSourceFld).ToString() + " - " + sourceFeature.get_Value(idxTargetFld).ToString());
}
}
else
{
AAState.WriteLine(" Fields Not Found");
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
//distance = proxOp.ReturnDistance(sourceFeature.Shape);
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
}
}
else if (sourceFeature.Class == inFeature.Class && sourceFeature.OID != inFeature.OID)
{
AAState.WriteLine(" matching fields specified");
int idxTargetFld = Globals.GetFieldIndex(sourceLayer, targetMatField);
int idxSourceFld = Globals.GetFieldIndex(inObject.Fields, sourceMatField);
if (idxSourceFld >= 0 && idxTargetFld >= 0)
{
AAState.WriteLine(" Fields Found");
if (inObject.get_Value(idxSourceFld).ToString() == sourceFeature.get_Value(idxTargetFld).ToString())
{
AAState.WriteLine(" Values Match");
// distance = proxOp.ReturnDistance(sourceFeature.Shape);
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
}
else
{
AAState.WriteLine(" Fields Not Found");
//distance = proxOp.ReturnDistance(sourceFeature.Shape);
IGeometry pTempGeo = sourceFeature.ShapeCopy;
pTempGeo.Project(inFeature.Shape.SpatialReference);
distance = proxOp.ReturnDistance(pTempGeo);
pTempGeo = null;
if (distance <= lastDistance)
{
nearestFeature = sourceFeature;
lastDistance = distance;
}
}
}
// sourceFeature = fCursor.NextFeature();
}
if (nearestFeature != null)
{
AAState.WriteLine(" Feature found: " + nearestFeature.Class.AliasName + ":" + nearestFeature.OID);
inObject.set_Value(intFldIdxs[0], nearestFeature.get_Value(sourceField));
found = true;
break;
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayer + ": field: " + sourceFieldName + " was not found");
}
}
else
{
AAState.WriteLine(" ERROR: " + sourceLayer + " was not found");
}
}
else
{
AAState.WriteLine(" ERROR: Empty source layer name");
}
}
if (!found)
{
//IField field = inObject.Fields.get_Field(intFldIdxs[0]);
//object newval = field.DefaultValue;
//if (newval == null)
//{
// if (field.IsNullable)
// {
// inObject.set_Value(intFldIdxs[0], null);
// }
//}
//else
//{
// inObject.set_Value(intFldIdxs[0], newval);
//}
}
}
}
}
catch (Exception ex)
{
AAState.WriteLine(" ERROR: NEAREST_FEATURE: " + ex.Message);
}
finally
{
AAState.WriteLine(" Finished: NEAREST_FEATURE");
}
break;
default:
// MessageBox.Show(valMethod + " for layer " + tableName + " is not a valid method, check the dynamic value table", "Attribute Assistant");
AAState.WriteLine("ERROR: " + valMethod + " for layer " + tableName + " is not a valid method, check the dynamic value table");
break;
}
}
catch (Exception ex)
{
MessageBox.Show("TableName:" + tableName + " FieldName:" + strFldNames[0] + System.Environment.NewLine + "ValueMethod:" + valMethod + " ValueData:" + valData + System.Environment.NewLine + "Message: " + ex.Message, "Attribute Assistant Message");
AAState.WriteLine("ERROR: TableName:" + tableName + " FieldName:" + strFldNames[0] + System.Environment.NewLine + "ValueMethod:" + valMethod + " ValueData:" + valData + System.Environment.NewLine + "Message: " + ex.Message);
}
}
else
{
AAState.WriteLine(" Rule not processed");
}
try
{
if (intFldIdxs.Count > 0 && strFldNames.Count > 0)
{
for (int p = 0; p < strFldNames.Count; p++)
{
// string fldname = strFldNames[p];
IRowChanges inChanges = inObject as IRowChanges;
bool changed = inChanges.get_ValueChanged(intFldIdxs[p]);
if (changed)
// if (fieldName.ToUpper() != "SHAPE")
try
{
// if (AAState.lastValueProperties.
// AAState.WriteLine(" Setting Last Value");
if (AAState.lastValueProperties.GetProperty(strFldNames[p]) != null)
{
AAState.WriteLine(" Setting Last Value");
if (mode == "ON_CREATE" && (inObject.get_Value(intFldIdxs[p]) == null || inObject.get_Value(intFldIdxs[p]).ToString() == ""))
{
AAState.WriteLine(" Null Value in the create Method, not storing in last value array");
}
else
{
AAState.WriteLine(" " + strFldNames[p] + ": " + inObject.get_Value(intFldIdxs[p]).ToString());
AAState.lastValueProperties.SetProperty(strFldNames[p], inObject.get_Value(intFldIdxs[p]));
}
}
else
{
if (mode == "ON_CREATE" && (inObject.get_Value(intFldIdxs[p]) == null || inObject.get_Value(intFldIdxs[p]).ToString() == ""))
{
AAState.WriteLine(" Null Value in the create Method, not storing in last value array");
}
else
{
AAState.WriteLine(" Setting Last Value");
AAState.WriteLine(" " + strFldNames[p] + ": " + inObject.get_Value(intFldIdxs[p]).ToString());
AAState.lastValueProperties.SetProperty(strFldNames[p], inObject.get_Value(intFldIdxs[p]));
}
}
}
catch
{
//AAState.WriteLine(" Error Setting Last Value " + inObject.Fields.get_Field(intFldIdxs[0]).Name);
}
}
}
}
catch
{
AAState.WriteLine(" Error Setting Last Value");
}
//if (inObject != null)
//{
// inChanges = inObject as IRowChanges;
// if (intFldIdxs.Count > 0)
// {
// if (intFldIdxs[0] > -1)
// {
// changed = inChanges.get_ValueChanged(intFldIdxs[0]);
// if (changed)
// // if (fieldName.ToUpper() != "SHAPE")
// try
// {
// // if (AAState.lastValueProperties.
// // AAState.WriteLine(" Setting Last Value");
// if (AAState.lastValueProperties.GetProperty(strFldNames[0]) != null)
// {
// AAState.WriteLine(" Setting Last Value");
// AAState.WriteLine(" " + strFldNames[0] + ": " + inObject.get_Value(intFldIdxs[0]).ToString());
// AAState.lastValueProperties.SetProperty(strFldNames[0], inObject.get_Value(intFldIdxs[0]));
// }
// else
// {
// AAState.WriteLine(" Setting Last Value");
// AAState.WriteLine(" " + strFldNames[0] + ": " + inObject.get_Value(intFldIdxs[0]).ToString());
// AAState.lastValueProperties.SetProperty(strFldNames[0], inObject.get_Value(intFldIdxs[0]));
// }
// }
// catch
// {
// //AAState.WriteLine(" Error Setting Last Value " + inObject.Fields.get_Field(intFldIdxs[0]).Name);
// }
// }
// }
//}
AAState.WriteLine(" ------------------------------------------------");
}
}
//for (int intFldIdxs[0] = 0; intFldIdxs[0] <= inObject.Fields.FieldCount; intFldIdxs[0]++)
//{
// stepProgressor.Step();
// bool editable = true;
// if (intFldIdxs[0] == inObject.Fields.FieldCount)
// {
// fieldObj = null;
// fieldName = "";
// stepProgressor.Message = "Checking rules for field null fields in" + inObject.Class.AliasName;
// progressDialog.Description = "Checking rules for field null fields in" + inObject.Class.AliasName;
// AAState.WriteLine("***********************************************************");
// AAState.WriteLine("");
// AAState.WriteLine("############ " + DateTime.Now + " ################");
// editable = true;
// // intFldIdxs[0]++;
// }
// else
// {
// fieldObj = inObject.Fields.get_Field(intFldIdxs[0]);
// fieldName = fieldObj.Name;
// stepProgressor.Message = "Checking rules for field " + fieldName + " in " + inObject.Class.AliasName;
// progressDialog.Description = "Checking rules for field " + fieldName + " in " + inObject.Class.AliasName;
// AAState.WriteLine("***********************************************************");
// AAState.WriteLine("");
// AAState.WriteLine("############ " + fieldName + " ################");
// AAState.WriteLine("############ " + DateTime.Now + " ################");
// AAState.WriteLine("Is field - " + fieldName + " Editable = " + fieldObj.Editable);
// editable = fieldObj.Editable;
// }
// bool proc = false;
// if (editable == true && fieldObj != null)
// {
// AAState.WriteLine("Checking rules for field " + fieldName + " in " + inObject.Class.AliasName);
// AAState._dv.RowFilter = "(TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And FIELDNAME = '" + fieldName + "' and " + modeVal;
// //AAState._dv.rw
// AAState.WriteLine(" Row Query: " + "TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And FIELDNAME = '" + fieldName + "' and " + modeVal);
// if (AAState._dv.Count == 0)
// {
// AAState._dv.RowFilter = "TABLENAME = '*' And FIELDNAME = '" + fieldName + "' and " + modeVal;
// AAState.WriteLine(" Query using " + fieldName + " did not produce any results, trying all fields");
// AAState.WriteLine(" Row Query: " + "TABLENAME = '*' And FIELDNAME = '" + fieldName + "' and " + modeVal);
// }
// if (AAState._dv.Count == 0)
// {
// AAState.WriteLine(" No entries found");
// proc = false;
// }
// else
// {
// proc = true;
// }
// }
// else if (editable && fieldObj == null)
// {
// fieldName = "";
// AAState._dv.RowFilter = "(TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And (FIELDNAME = '" + fieldName + "' or FIELDNAME IS NULL) and " + modeVal;
// //AAState._dv.rw
// AAState.WriteLine(" Row Query: " + "TABLENAME = '" + tableName + "' OR TABLENAME like '" + tableName + "|*' OR TABLENAME like '" + tableName + "|%') And (FIELDNAME = '" + fieldName + "' or FIELDNAME IS NULL) and " + modeVal);
// if (AAState._dv.Count == 0)
// {
// AAState._dv.RowFilter = "TABLENAME = '*' And (FIELDNAME = '" + fieldName + "' or FIELDNAME IS NULL) and " + modeVal;
// AAState.WriteLine(" Query using " + fieldName + " did not produce any results, trying all fields");
// AAState.WriteLine(" Row Query: " + "TABLENAME = '*' And And (FIELDNAME = '" + fieldName + "' or FIELDNAME IS NULL) and " + modeVal);
// }
// if (AAState._dv.Count == 0)
// {
// AAState.WriteLine(" No entries found");
// proc = false;
// }
// else
// {
// proc = true;
// }
// }
//}
}
return false;
}
catch (Exception ex)
{
MessageBox.Show("Problem in setup." + System.Environment.NewLine + "Message:" + ex.Message, "Attribute Assistant Message");
AAState.WriteLine("Error in setup");
return false;
}
finally
{
if (AAState._tab == inObject.Class || AAState._gentab == inObject.Class)
{
AAState.reInitExt();
}
if (progressDialog != null)
{
progressDialog.HideDialog();
}
AAState.WriteLine("DONE");
AAState.WriteLine("---------------------------------------");
if (fCursor != null)
{
Marshal.ReleaseComObject(fCursor);
GC.Collect(300);
GC.WaitForFullGCComplete();
}
inFeature = null;
mseg = null;
netFeat = null;
iEdgeFeat = null;
iJuncFeat = null;
progressDialogFactory = null;
stepProgressor = null;
progressDialog = null;
trackCancel = null;
}
}
/// <summary>
///
/// </summary>
/// <param name="deletedFeature"></param>
/// <param name="testFeatureClass"></param>
/// <param name="searchPointFilter"></param>
private void TestRelationMembership(IFeature deletedFeature, IFeatureClass testFeatureClass, ISpatialFilter searchPointFilter)
{
using (ESRI.ArcGIS.OSM.OSMClassExtension.ComReleaser comReleaser = new ESRI.ArcGIS.OSM.OSMClassExtension.ComReleaser())
{
int testMemberOfFieldIndex = testFeatureClass.Fields.FindField("osmMemberOf");
int testMembersFieldIndex = testFeatureClass.Fields.FindField("osmMembers");
int testOsmIDFieldIndex = testFeatureClass.Fields.FindField("OSMID");
IFeatureCursor searchCursor = testFeatureClass.Search(searchPointFilter, false);
comReleaser.ManageLifetime(searchCursor);
IFeature touchedFeature = searchCursor.NextFeature();
while (touchedFeature != null)
{
long osmID = 0;
if (testOsmIDFieldIndex > -1)
{
object osmIDValue = touchedFeature.get_Value(testOsmIDFieldIndex);
if (osmIDValue != DBNull.Value)
{
osmID = Convert.ToInt64(osmIDValue);
}
}
if (testMembersFieldIndex > -1)
{
ESRI.ArcGIS.OSM.OSMClassExtension.member[] relationMembers = _osmUtility.retrieveMembers(touchedFeature, testMembersFieldIndex);
if (relationMembers != null)
{
if (relationMembers.Length > 0)
{
string abortMessage = String.Format(resourceManager.GetString("OSMEditor_FeatureInspector_pointmemberofrelation"), osmID);
MessageBox.Show(abortMessage, resourceManager.GetString("OSMEditor_FeatureInspector_relationconflictcaption"), MessageBoxButtons.OK, MessageBoxIcon.Stop);
m_editor3.AbortOperation();
return;
}
}
}
if (testMemberOfFieldIndex > -1)
{
List<string> isMemberOfList = _osmUtility.retrieveIsMemberOf(touchedFeature, testMemberOfFieldIndex);
Dictionary<string, string> dictofParentsAndTypes = _osmUtility.parseIsMemberOfList(isMemberOfList);
StringBuilder typeAndIDString = new StringBuilder();
foreach (var item in dictofParentsAndTypes)
{
switch (item.Value)
{
case "rel":
typeAndIDString.Append(resourceManager.GetString("OSMEditor_FeatureInspector_relationidtext") + item.Key + ",");
break;
case "ply":
typeAndIDString.Append(resourceManager.GetString("OSMEditor_FeatureInspector_polygonidtext") + item.Key + ",");
break;
case "ln":
typeAndIDString.Append(resourceManager.GetString("OSMEditor_FeatureInspector_polylineidtext") + item.Key + ",");
break;
case "pt":
typeAndIDString.Append(resourceManager.GetString("OSMEditor_FeatureInspector_pointidtext") + item.Key + ",");
break;
default:
break;
}
}
if (typeAndIDString.Length > 0)
{
string parentsString = typeAndIDString.ToString(0, typeAndIDString.Length - 1);
string abortMessage = String.Format(resourceManager.GetString("OSMEditor_FeatureInspector_pointmemberofrelation"), parentsString);
MessageBox.Show(abortMessage, resourceManager.GetString("OSMEditor_FeatureInspector_relationconflictcaption"), MessageBoxButtons.OK, MessageBoxIcon.Stop);
m_editor3.AbortOperation();
return;
}
}
touchedFeature = searchCursor.NextFeature();
}
}
}
/// <summary>
/// ��㡢�յ����Ҫ�ӱ߶���
/// </summary>
/// <param name="bIsFromOver"></param>
/// <param name="bIsToOver"></param>
/// <param name="ipToSpatialFilter"></param>
/// <param name="ipFromSpatialFilter"></param>
/// <param name="ipSourceRow"></param>
/// <param name="ipSourceCursor"></param>
/// <param name="ipTargetSelectionSet"></param>
/// <param name="sMatchEdgeWhereClause"></param>
/// <param name="lSourceRowOID"></param>
/// <param name="sSourceRowOID"></param>
/// <param name="sOIDs"></param>
/// <param name="sCheckInfos"></param>
/// <returns></returns>
private bool JointFromToPoints(bool bIsFromOver, bool bIsToOver, ISpatialFilter ipToSpatialFilter,
ISpatialFilter ipFromSpatialFilter,
ref IRow ipSourceRow, ICursor ipSourceCursor, ISelectionSet ipTargetSelectionSet,
string sMatchEdgeWhereClause, int lSourceRowOID, string sSourceRowOID,
ref List<string> sOIDs, ref List<string> sCheckInfos)
{
try
{
int lFromSelectionCount, lToSelectionCount;
ISelectionSet ipFromSelectionSet = null;
ISelectionSet ipToSelectionSet = null;
if (bIsFromOver == false)
{
try
{
ipFromSelectionSet = ipTargetSelectionSet.Select(ipFromSpatialFilter,
esriSelectionType.esriSelectionTypeHybrid,
esriSelectionOption.esriSelectionOptionNormal,
null);
}
catch (Exception ex)
{
SendMessage(enumMessageType.Exception, ex.ToString());
Marshal.ReleaseComObject(ipSourceRow);
ipSourceRow = ipSourceCursor.NextRow();
return false;
}
lFromSelectionCount = ipFromSelectionSet.Count;
}
else
{
lFromSelectionCount = 0;
}
if (bIsToOver == false)
{
try
{
ipToSelectionSet =
ipTargetSelectionSet.Select(ipToSpatialFilter,
esriSelectionType.esriSelectionTypeHybrid,
esriSelectionOption.esriSelectionOptionNormal,
null);
}
catch (Exception ex)
{
SendMessage(enumMessageType.Exception, ex.ToString());
Marshal.ReleaseComObject(ipSourceRow);
ipSourceRow = ipSourceCursor.NextRow();
return false;
}
lToSelectionCount = ipToSelectionSet.Count;
}
else
{
lToSelectionCount = 0;
}
if (lFromSelectionCount > 0 && lToSelectionCount > 0)
{
//�������յ��ͼ��ͼ�νӱ�
ipFromSpatialFilter.WhereClause = sMatchEdgeWhereClause;
ipToSpatialFilter.WhereClause = sMatchEdgeWhereClause;
ISelectionSet ipFromAttrSelectionSet, ipToAttrSelectionSet;
ipFromAttrSelectionSet =
ipFromSelectionSet.Select(ipFromSpatialFilter,
esriSelectionType.esriSelectionTypeHybrid,
esriSelectionOption.esriSelectionOptionNormal, null);
ipToAttrSelectionSet =
ipToSelectionSet.Select(ipToSpatialFilter,
esriSelectionType.esriSelectionTypeHybrid,
esriSelectionOption.esriSelectionOptionNormal, null);
int lFromAttrSelectionCount, lToAttrSelectionCount;
lFromAttrSelectionCount = ipFromAttrSelectionSet.Count;
lToAttrSelectionCount = ipToAttrSelectionSet.Count;
if (lFromAttrSelectionCount > 0 && lToAttrSelectionCount > 0)
{
//�����յ������Խӱ�
//�ж������յ�Ľӱ߶����Ƿ����һ��
ICursor ipFromAttrCursor, ipToAttrCursor;
ipFromAttrSelectionSet.Search(null, false, out ipFromAttrCursor);
ipToAttrSelectionSet.Search(null, false, out ipToAttrCursor);
//����
IRow ipFromAttrRow = ipFromAttrCursor.NextRow();
int nFromAttr = 0;
while (ipFromAttrRow != null)
{
int lFromAttrOID = ipFromAttrRow.OID;
if (lFromAttrOID != lSourceRowOID)
{
nFromAttr++;
}
ipFromAttrRow = ipFromAttrCursor.NextRow();
}
//�ж��յ�
IRow ipToAttrRow = ipToAttrCursor.NextRow();
int nToAttr = 0;
while (ipToAttrRow != null)
{
int lToAttrOID = ipToAttrRow.OID;
if (lToAttrOID != lSourceRowOID)
{
nToAttr++;
}
ipToAttrRow = ipToAttrCursor.NextRow();
}
Marshal.ReleaseComObject(ipFromAttrCursor);
Marshal.ReleaseComObject(ipToAttrCursor);
string sInfo = null;
if (nFromAttr > 1 && nToAttr > 1)
{
sOIDs.Add(sSourceRowOID);
sInfo = sSourceRowOID + "Ҫ����㴦��" + nFromAttr + "���ӱ߶���;�յ㴦��" + nToAttr +
"���ӱ߶���";
sCheckInfos.Add(sInfo);
}
else if (nFromAttr > 1)
{
sOIDs.Add(sSourceRowOID);
sInfo = sSourceRowOID + "Ҫ����㴦��" + nFromAttr + "���ӱ߶���";
sCheckInfos.Add(sInfo);
}
else if (nToAttr > 1)
{
sOIDs.Add(sSourceRowOID);
sInfo = sSourceRowOID + "Ҫ���յ㴦��" + nToAttr + "���ӱ߶���";
sCheckInfos.Add(sInfo);
}
}
else if (lFromAttrSelectionCount > 0)
{
//��������Խӱ߶���,�յ�û�����Խӱ߶���
ICursor ipFromAttrCursor = null;
ipFromAttrSelectionSet.Search(null, false, out ipFromAttrCursor);
//����
IRow ipFromAttrRow = ipFromAttrCursor.NextRow();
int nFromAttr = 0;
while (ipFromAttrRow != null)
{
int lFromAttrOID = ipFromAttrRow.OID;
if (lFromAttrOID != lSourceRowOID)
{
nFromAttr++;
}
ipFromAttrRow = ipFromAttrCursor.NextRow();
}
Marshal.ReleaseComObject(ipFromAttrCursor);
if (nFromAttr > 1)
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "Ҫ����㴦��" + nFromAttr + "���ӱ߶���,�����յ㴦�ӱ߶�������Բ�ͬ";
sCheckInfos.Add(sInfo);
}
else
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "Ҫ���յ㴦�ӱ߶�������Բ�ͬ";
sCheckInfos.Add(sInfo);
}
}
else if (lToAttrSelectionCount > 0)
{
//�յ������Խӱ߶���,���û�����Խӱ߶���
//�ж��յ�
ICursor ipToAttrCursor = null;
ipToAttrSelectionSet.Search(null, false, out ipToAttrCursor);
IRow ipToAttrRow = ipToAttrCursor.NextRow();
int nToAttr = 0;
while (ipToAttrRow != null)
{
int lToAttrOID = ipToAttrRow.OID;
if (lToAttrOID != lSourceRowOID)
{
nToAttr++;
}
ipToAttrRow = ipToAttrCursor.NextRow();
}
Marshal.ReleaseComObject(ipToAttrCursor);
if (nToAttr > 1)
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "Ҫ���յ㴦��" + nToAttr + "���ӱ߶���,������㴦�ӱ߶�������Բ�ͬ";
sCheckInfos.Add(sInfo);
}
else
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "Ҫ����㴦�ӱ߶�������Բ�ͬ";
sCheckInfos.Add(sInfo);
}
}
else
{
sOIDs.Add(sSourceRowOID);
//�����յ㶼û�����Խӱ߶���
string sInfo = sSourceRowOID + "Ҫ�������յ㴦�нӱ߶���,�����Բ�ͬ";
sCheckInfos.Add(sInfo);
}
}
else if (lFromSelectionCount > 0)
{
ipFromSpatialFilter.WhereClause = sMatchEdgeWhereClause;
ISelectionSet ipFromAttrSelectionSet =
ipFromSelectionSet.Select(ipFromSpatialFilter,
esriSelectionType.esriSelectionTypeHybrid,
esriSelectionOption.esriSelectionOptionNormal, null);
int lFromAttrSelectionCount = ipFromAttrSelectionSet.Count;
if (lFromAttrSelectionCount > 0)
{
//��������Խӱ߶���
ICursor ipFromAttrCursor = null;
ipFromAttrSelectionSet.Search(null, false, out ipFromAttrCursor);
//����
IRow ipFromAttrRow = ipFromAttrCursor.NextRow();
int nFromAttr = 0;
while (ipFromAttrRow != null)
{
int lFromAttrOID = ipFromAttrRow.OID;
if (lFromAttrOID != lSourceRowOID)
{
nFromAttr++;
}
ipFromAttrRow = ipFromAttrCursor.NextRow();
}
Marshal.ReleaseComObject(ipFromAttrCursor);
if (nFromAttr > 1)
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "Ҫ����㴦��" + nFromAttr + "���ӱ߶���,�����յ㴦ȱ�ٽӱ߶���";
sCheckInfos.Add(sInfo);
}
else
{
if (nFromAttr < 1)
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "Ҫ���յ㴦ȱ�ٽӱ߶���";
sCheckInfos.Add(sInfo);
}
}
}
else
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "Ҫ����㴦�нӱ߶���,�����Բ�ͬ;�����յ㴦ȱ�ٽӱ߶���";
sCheckInfos.Add(sInfo);
}
}
else if (lToSelectionCount > 0)
{
ipToSpatialFilter.WhereClause = sMatchEdgeWhereClause;
ISelectionSet ipToAttrSelectionSet =
ipToSelectionSet.Select(ipToSpatialFilter,
esriSelectionType.esriSelectionTypeHybrid,
esriSelectionOption.esriSelectionOptionNormal, null);
int lToAttrSelectionCount = ipToAttrSelectionSet.Count;
if (lToAttrSelectionCount > 0)
{
//�յ������Խӱ߶���
ICursor ipToAttrCursor = null;
ipToAttrSelectionSet.Search(null, false, out ipToAttrCursor);
//�ж��յ�
IRow ipToAttrRow = ipToAttrCursor.NextRow();
int nToAttr = 0;
while (ipToAttrRow != null)
{
int lToAttrOID = ipToAttrRow.OID;
if (lToAttrOID != lSourceRowOID)
{
nToAttr++;
}
ipToAttrRow = ipToAttrCursor.NextRow();
}
Marshal.ReleaseComObject(ipToAttrCursor);
if (nToAttr > 1)
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "Ҫ���յ㴦��" + nToAttr + "���ӱ߶���,������㴦ȱ�ٽӱ߶���";
sCheckInfos.Add(sInfo);
}
else
{
if (nToAttr < 1)
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "%sҪ����㴦ȱ�ٽӱ߶���";
sCheckInfos.Add(sInfo);
}
}
}
else
{
sOIDs.Add(sSourceRowOID);
string sInfo = sSourceRowOID + "%sҪ���յ㴦�нӱ߶���,�����Բ�ͬ;������㴦ȱ�ٽӱ߶���";
sCheckInfos.Add(sInfo);
}
}
else
{
if (bIsFromOver == false && bIsToOver == false)
{
sOIDs.Add(sSourceRowOID);
//û��ͼ�νӱ�
string sInfo = sSourceRowOID + "Ҫ�������յ㴦��ȱ�ٶ�Ӧ�Ľӱ߶���";
sCheckInfos.Add(sInfo);
}
}
if (ipFromSelectionSet != null)
{
Marshal.ReleaseComObject(ipFromSelectionSet);
}
if (ipToSelectionSet != null)
{
Marshal.ReleaseComObject(ipToSelectionSet);
}
return true;
}
catch (Exception ex)
{
SendMessage(enumMessageType.Exception, ex.ToString());
Marshal.ReleaseComObject(ipSourceRow);
ipSourceRow = ipSourceCursor.NextRow();
return false;
}
}
