public static void DeleteFeatureClass(IDataset data)
{
if (data.CanDelete())
{
data.Delete();
}
}
public IEnumerable<double> GetEstimatedClassValues(IDataset dataset, IEnumerable<int> rows) {
double[,] inputData = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables, rows);
int n = inputData.GetLength(0);
int columns = inputData.GetLength(1);
double[] x = new double[columns];
double[] y = new double[classValues.Length];
for (int row = 0; row < n; row++) {
for (int column = 0; column < columns; column++) {
x[column] = inputData[row, column];
}
alglib.mnlprocess(logitModel, x, ref y);
// find class for with the largest probability value
int maxProbClassIndex = 0;
double maxProb = y[0];
for (int i = 1; i < y.Length; i++) {
if (maxProb < y[i]) {
maxProb = y[i];
maxProbClassIndex = i;
}
}
yield return classValues[maxProbClassIndex];
}
}
public IEnumerable<IEnumerable<double>> GetPrognosedValues(IDataset dataset, IEnumerable<int> rows, IEnumerable<int> horizons) {
var rowsEnumerator = rows.GetEnumerator();
var horizonsEnumerator = horizons.GetEnumerator();
var targetValues = dataset.GetReadOnlyDoubleValues(TargetVariable);
// produce a n-step forecast for all rows
while (rowsEnumerator.MoveNext() & horizonsEnumerator.MoveNext()) {
int row = rowsEnumerator.Current;
int horizon = horizonsEnumerator.Current;
if (row - TimeOffset < 0) {
yield return Enumerable.Repeat(double.NaN, horizon);
continue;
}
double[] prognosis = new double[horizon];
for (int h = 0; h < horizon; h++) {
double estimatedValue = 0.0;
for (int i = 1; i <= TimeOffset; i++) {
int offset = h - i;
if (offset >= 0) estimatedValue += prognosis[offset] * Phi[i - 1];
else estimatedValue += targetValues[row + offset] * Phi[i - 1];
}
estimatedValue += Constant;
prognosis[h] = estimatedValue;
}
yield return prognosis;
}
if (rowsEnumerator.MoveNext() || horizonsEnumerator.MoveNext())
throw new ArgumentException("Number of elements in rows and horizon enumerations doesn't match.");
}
public static IEnumerable<int> FindClosestCenters(IEnumerable<double[]> centers, IDataset dataset, IEnumerable<string> allowedInputVariables, IEnumerable<int> rows) {
int nRows = rows.Count();
int nCols = allowedInputVariables.Count();
int[] closestCenter = new int[nRows];
double[] bestCenterDistance = Enumerable.Repeat(double.MaxValue, nRows).ToArray();
int centerIndex = 1;
foreach (double[] center in centers) {
if (nCols != center.Length) throw new ArgumentException();
int rowIndex = 0;
foreach (var row in rows) {
// calc euclidian distance of point to center
double centerDistance = 0;
int col = 0;
foreach (var inputVariable in allowedInputVariables) {
double d = center[col++] - dataset.GetDoubleValue(inputVariable, row);
d = d * d; // square;
centerDistance += d;
if (centerDistance > bestCenterDistance[rowIndex]) break;
}
if (centerDistance < bestCenterDistance[rowIndex]) {
bestCenterDistance[rowIndex] = centerDistance;
closestCenter[rowIndex] = centerIndex;
}
rowIndex++;
}
centerIndex++;
}
return closestCenter;
}
public NetworkDataset(string configXML, IDataset osmDataset, string ndsName, IGPMessages messages, ITrackCancel trackCancel)
{
_xml = new NetworkDatasetXML(configXML, RESMGR);
_osmDataset = osmDataset;
_ndsName = ndsName;
_messages = messages;
_trackCancel = trackCancel;
IDataElement deOSM = GPUtil.MakeDataElementFromNameObject(_osmDataset.FullName);
_dsPath = deOSM.CatalogPath;
_osmLineName = _osmDataset.Name + "_osm_ln";
_osmLinePath = _dsPath + "\\" + _osmLineName;
_osmPointName = _osmDataset.Name + "_osm_pt";
_osmPointPath = _dsPath + "\\" + _osmPointName;
// Get the extent from the point feature class
// NOTE: the feature dataset is not used for this because exceptions occur (SDE only)
// if a feature class was recently deleted from the feature dataset.
IFeatureClass fcPoint = ((IFeatureWorkspace)_osmDataset.Workspace).OpenFeatureClass(_osmPointName);
IGeoDataset gds = (IGeoDataset)fcPoint;
_extent = gds.Extent;
_spatialReference = gds.SpatialReference;
}
public Scaling(IDataset ds, IEnumerable<string> variables, IEnumerable<int> rows) {
foreach (var variable in variables) {
var values = ds.GetDoubleValues(variable, rows);
var min = values.Where(x => !double.IsNaN(x)).Min();
var max = values.Where(x => !double.IsNaN(x)).Max();
scalingParameters[variable] = Tuple.Create(min, max);
}
}
public static string GetClassShortName(IDataset paramDS)
{
if (paramDS == null)
{
return "";
}
return GetClassShortName(paramDS.Name.ToUpper());
}
public Dataset(IDataset pIDataset,IWorkspace pWorkspace,bool bCut,IGeometry pCutGeomtry)
{
m_pIDataset = pIDataset;
m_pIWorkspace = pWorkspace;
m_cutGeometry = pCutGeomtry;
m_bCut = bCut;
InitialProjection();
InitialFeatureList();
}
public IEnumerable<IEnumerable<double>> GetEstimatedClassValueVectors(IDataset dataset, IEnumerable<int> rows) {
var estimatedValuesEnumerators = (from model in models
select model.GetEstimatedClassValues(dataset, rows).GetEnumerator())
.ToList();
while (estimatedValuesEnumerators.All(en => en.MoveNext())) {
yield return from enumerator in estimatedValuesEnumerators
select enumerator.Current;
}
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="path">
/// Path to the raster file that represents the map.
/// </param>
/// <param name="ecoregions">Dataset of ecoregions</param>
public Map(string path,
IDataset ecoregions)
{
this.path = path;
this.ecoregions = ecoregions;
IInputRaster<Pixel> map = Util.Raster.Open<Pixel>(path);
using (map) {
this.metadata = map.Metadata;
}
}
public NetworkTurns(string turnClassName, IDataset osmDataset, INetworkDataset nds)
{
_turnClassName = turnClassName;
_osmDataset = osmDataset;
_networkDataset = nds;
IGPUtilities gpUtil = new GPUtilitiesClass();
IDataElement de = gpUtil.MakeDataElementFromNameObject(osmDataset.FullName);
_dsPath = de.CatalogPath;
}
public IEnumerable<double> GetEstimatedClassValues(IDataset dataset, IEnumerable<int> rows) {
foreach (var estimatedValuesVector in GetEstimatedClassValueVectors(dataset, rows)) {
// return the class which is most often occuring
yield return
estimatedValuesVector
.GroupBy(x => x)
.OrderBy(g => -g.Count())
.Select(g => g.Key)
.First();
}
}
public NcaModel(int k, double[,] transformationMatrix, IDataset dataset, IEnumerable<int> rows, string targetVariable, IEnumerable<string> allowedInputVariables, double[] classValues) {
Name = ItemName;
Description = ItemDescription;
this.transformationMatrix = (double[,])transformationMatrix.Clone();
this.allowedInputVariables = allowedInputVariables.ToArray();
this.targetVariable = targetVariable;
this.classValues = (double[])classValues.Clone();
var ds = ReduceDataset(dataset, rows);
nnModel = new NearestNeighbourModel(ds, Enumerable.Range(0, ds.Rows), k, ds.VariableNames.Last(), ds.VariableNames.Take(transformationMatrix.GetLength(1)), classValues);
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="path">
/// Path to the raster file that represents the map.
/// </param>
/// <param name="ecoregions">
/// The dataset of ecoregions that are in the map.
/// </param>
/// <param name="rasterFactory">
/// The raster factory to use to read the map.
/// </param>
public Map(string path,
IDataset ecoregions,
IRasterFactory rasterFactory)
{
this.path = path;
this.ecoregions = ecoregions;
this.rasterFactory = rasterFactory;
IInputRaster<Pixel> map = rasterFactory.OpenRaster<Pixel>(path);
using (map) {
this.metadata = map.Metadata;
}
}
//
// CONSTRUCTOR
//
public ZPath(IDataset dataset)
{
IWorkspace workspace = dataset.Workspace;
ISQLSyntax sqlSyntax = (ISQLSyntax)workspace;
string database;
string owner;
string table;
sqlSyntax.ParseTableName(dataset.Name, out database, out owner, out table);
this.Database = database;
this.Owner = owner;
this.Table = table;
}
public string Format(ISymbolicExpressionTree symbolicExpressionTree, IDataset dataset) {
var stringBuilder = new StringBuilder();
if (dataset != null) CalculateVariableMapping(symbolicExpressionTree, dataset);
stringBuilder.Append("=");
stringBuilder.Append(FormatRecursively(symbolicExpressionTree.Root));
foreach (var variable in variableNameMapping) {
stringBuilder.AppendLine();
stringBuilder.Append(variable.Key + " = " + variable.Value);
}
return stringBuilder.ToString();
}
public static double CalculateIntraClusterSumOfSquares(KMeansClusteringModel model, IDataset dataset, IEnumerable<int> rows) {
List<int> clusterValues = model.GetClusterValues(dataset, rows).ToList();
List<string> allowedInputVariables = model.AllowedInputVariables.ToList();
int nCols = allowedInputVariables.Count;
Dictionary<int, List<double[]>> clusterPoints = new Dictionary<int, List<double[]>>();
Dictionary<int, double[]> clusterMeans = new Dictionary<int, double[]>();
foreach (var clusterValue in clusterValues.Distinct()) {
clusterPoints.Add(clusterValue, new List<double[]>());
}
// collect points of clusters
int clusterValueIndex = 0;
foreach (var row in rows) {
double[] p = new double[allowedInputVariables.Count];
for (int i = 0; i < nCols; i++) {
p[i] = dataset.GetDoubleValue(allowedInputVariables[i], row);
}
clusterPoints[clusterValues[clusterValueIndex++]].Add(p);
}
// calculate cluster means
foreach (var pair in clusterPoints) {
double[] mean = new double[nCols];
foreach (var p in pair.Value) {
for (int i = 0; i < nCols; i++) {
mean[i] += p[i];
}
}
for (int i = 0; i < nCols; i++) {
mean[i] /= pair.Value.Count;
}
clusterMeans[pair.Key] = mean;
}
// calculate distances
double allCenterDistances = 0;
foreach (var pair in clusterMeans) {
double[] mean = pair.Value;
double centerDistances = 0;
foreach (var clusterPoint in clusterPoints[pair.Key]) {
double centerDistance = 0;
for (int i = 0; i < nCols; i++) {
double d = mean[i] - clusterPoint[i];
d = d * d;
centerDistance += d;
}
centerDistances += centerDistance;
}
allCenterDistances += centerDistances;
}
return allCenterDistances;
}
public FeatureSelectionRegressionProblemData(IDataset ds, IEnumerable<string> allowedInputVariables, string targetVariable, string[] selectedFeatures, double[] weights, double optimalRSquared)
: base(ds, allowedInputVariables, targetVariable) {
if (selectedFeatures.Length != weights.Length) throw new ArgumentException("Length of selected features vector does not match the length of the weights vector");
if (optimalRSquared < 0 || optimalRSquared > 1) throw new ArgumentException("Optimal R² is not in range [0..1]");
Parameters.Add(new FixedValueParameter<StringArray>(
SelectedFeaturesParameterName,
"Array of features used to generate the target values.",
new StringArray(selectedFeatures).AsReadOnly()));
Parameters.Add(new FixedValueParameter<DoubleArray>(
WeightsParameterName,
"Array of weights used to generate the target values.",
(DoubleArray)(new DoubleArray(weights).AsReadOnly())));
Parameters.Add(new FixedValueParameter<DoubleValue>(
OptimalRSquaredParameterName,
"R² of the optimal solution.",
(DoubleValue)(new DoubleValue(optimalRSquared).AsReadOnly())));
}
protected static double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
IDataset dataset, IEnumerable<int> rows) {
//optimization: constant nodes return always the same value
ConstantTreeNode constantNode = node as ConstantTreeNode;
if (constantNode != null) return constantNode.Value;
var rootSymbol = new ProgramRootSymbol().CreateTreeNode();
var startSymbol = new StartSymbol().CreateTreeNode();
rootSymbol.AddSubtree(startSymbol);
startSymbol.AddSubtree((ISymbolicExpressionTreeNode)node.Clone());
var tempTree = new SymbolicExpressionTree(rootSymbol);
// clone ADFs of source tree
for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) {
tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone());
}
return interpreter.GetSymbolicExpressionTreeValues(tempTree, dataset, rows).Median();
}
public static double[,] PrepareAndScaleInputMatrix(IDataset dataset, IEnumerable<string> variables, IEnumerable<int> rows, Scaling scaling) {
List<string> variablesList = variables.ToList();
List<int> rowsList = rows.ToList();
double[,] matrix = new double[rowsList.Count, variablesList.Count];
int col = 0;
foreach (string column in variables) {
var values = scaling.GetScaledValues(dataset, column, rows);
int row = 0;
foreach (var value in values) {
matrix[row, col] = value;
row++;
}
col++;
}
return matrix;
}
public IEnumerable<IEnumerable<double>> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, IEnumerable<int> horizons) {
if (CheckExpressionsWithIntervalArithmetic.Value)
throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
if (targetVariableCache == null || targetVariableCache.GetLength(0) < dataset.Rows)
targetVariableCache = dataset.GetDoubleValues(TargetVariable).ToArray();
if (invalidateCacheIndexes == null)
invalidateCacheIndexes = new List<int>(10);
string targetVariable = TargetVariable;
lock (EvaluatedSolutions) {
EvaluatedSolutions.Value++; // increment the evaluated solutions counter
}
var state = PrepareInterpreterState(tree, dataset, targetVariableCache, TargetVariable);
var rowsEnumerator = rows.GetEnumerator();
var horizonsEnumerator = horizons.GetEnumerator();
// produce a n-step forecast for all rows
while (rowsEnumerator.MoveNext() & horizonsEnumerator.MoveNext()) {
int row = rowsEnumerator.Current;
int horizon = horizonsEnumerator.Current;
double[] vProgs = new double[horizon];
for (int i = 0; i < horizon; i++) {
int localRow = i + row; // create a local variable for the ref parameter
vProgs[i] = Evaluate(dataset, ref localRow, state);
targetVariableCache[localRow] = vProgs[i];
invalidateCacheIndexes.Add(localRow);
state.Reset();
}
yield return vProgs;
int j = 0;
foreach (var targetValue in dataset.GetDoubleValues(targetVariable, invalidateCacheIndexes)) {
targetVariableCache[invalidateCacheIndexes[j]] = targetValue;
j++;
}
invalidateCacheIndexes.Clear();
}
if (rowsEnumerator.MoveNext() || horizonsEnumerator.MoveNext())
throw new ArgumentException("Number of elements in rows and horizon enumerations doesn't match.");
}
private void CalculateElements(IDataset dataset, IDependencyCalculator calc, string partition, string variable = null, int frames = 0, double[,] alreadyCalculated = null) {
var indices = GetRelevantIndices(problemData, partition);
bwInfo = new BackgroundWorkerInfo {
Dataset = dataset, Calculator = calc, Partition = partition, Indices = indices,
Variable = variable, Frames = frames, AlreadyCalculated = alreadyCalculated
};
if (bw == null) {
bw = new BackgroundWorker();
bw.WorkerReportsProgress = true;
bw.WorkerSupportsCancellation = true;
bw.DoWork += new DoWorkEventHandler(BwDoWork);
bw.ProgressChanged += new ProgressChangedEventHandler(BwProgressChanged);
bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BwRunWorkerCompleted);
}
if (bw.IsBusy) {
bw.CancelAsync();
} else {
bw.RunWorkerAsync(bwInfo);
}
}
// uses sorting to return the values in the order of rows, instead of using nested for loops
// to avoid O(n²) runtime
public IEnumerable<double> GetEstimatedClassValues(IDataset dataset, IEnumerable<int> rows) {
var values = dataset.GetDoubleValues(Variable, rows).ToArray();
var rowsArray = rows.ToArray();
var order = Enumerable.Range(0, rowsArray.Length).ToArray();
double[] estimated = new double[rowsArray.Length];
Array.Sort(rowsArray, order);
Array.Sort(values, rowsArray);
int curSplit = 0, curIndex = 0;
while (curIndex < values.Length && Double.IsNaN(values[curIndex])) {
estimated[curIndex] = MissingValuesClass;
curIndex++;
}
while (curSplit < Splits.Length) {
while (curIndex < values.Length && Splits[curSplit] > values[curIndex]) {
estimated[curIndex] = classes[curSplit];
curIndex++;
}
curSplit++;
}
Array.Sort(rowsArray, estimated);
Array.Sort(order, estimated);
return estimated;
}
public NestedDesignAnalysisModel(IDataset dataset)
: base(dataset, "NestedDesignAnalysis")
{
}
public bool MergePlans(ITable ParcelTable, Dictionary <int, int> Lookup, string[] sInClause, bool Unversioned,
IStepProgressor StepProgressor, ITrackCancel TrackCancel)
{
IDataset pDS = (IDataset)ParcelTable;
IWorkspace pWS = pDS.Workspace;
Int32 iPlanIDX = ParcelTable.Fields.FindField("PLANID");
ISQLSyntax pSQLSyntax = (ISQLSyntax)pWS;
string sPref = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
string sSuff = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
ITableWrite pTableWr = (ITableWrite)ParcelTable;
bool bCont = true;
int zz = 0;
int iCnt = sInClause.GetLength(0);
try
{
foreach (string ss in sInClause)
{
if (ss == null)
{
continue;
}
IQueryFilter pQF = new QueryFilterClass();
string InClause = ss.Replace(",", " ").Trim();
InClause = InClause.Replace(" ", ",");
string FieldName = "PLANID";
pQF.WhereClause = sPref + FieldName + sSuff + " IN (" + InClause + ")";
if (!ParcelTable.HasOID)
{
MessageBox.Show("Has no OID");
}
int iRowCnt = ParcelTable.RowCount(pQF);
ICursor pCur = null;
if (Unversioned)
{
pCur = pTableWr.UpdateRows(pQF, false);
}
else
{
pCur = ParcelTable.Update(pQF, false);
}
//Check if the cancel button was pressed. If so, stop process
if (TrackCancel != null)
{
bCont = TrackCancel.Continue();
}
if (!bCont)
{
break;
}
//now for each of these parcels, use the dictionary to re-assign the plan id value
IRow pParcel = pCur.NextRow();
if (StepProgressor != null)
{
StepProgressor.MinRange = StepProgressor.Position; //reset the progress bar position
StepProgressor.MaxRange = StepProgressor.Position + iRowCnt;
if (StepProgressor.Position < StepProgressor.MaxRange)
{
StepProgressor.Step();
}
StepProgressor.Message = "Moving parcels to target plans...step " + Convert.ToString(++zz) + " of " + Convert.ToString(iCnt);
}
if (pQF != null)
{
Marshal.ReleaseComObject(pQF);
}
while (pParcel != null)
{
//Check if the cancel button was pressed. If so, stop process
if (TrackCancel != null)
{
bCont = TrackCancel.Continue();
}
if (!bCont)
{
break;
}
int MergePlanID = (int)pParcel.get_Value(iPlanIDX);
int TargetPlanID = -1;
if (Lookup.TryGetValue(MergePlanID, out TargetPlanID))
{
pParcel.set_Value(iPlanIDX, TargetPlanID);
pCur.UpdateRow(pParcel);
}
Marshal.ReleaseComObject(pParcel);
pParcel = pCur.NextRow();
if (StepProgressor != null)
{
if (StepProgressor.Position < StepProgressor.MaxRange)
{
StepProgressor.Step();
}
}
}
if (pCur != null)
{
Marshal.ReleaseComObject(pCur);
}
if (!bCont)
{
break;
}
}
if (pTableWr != null)
{
Marshal.ReleaseComObject(pTableWr);
}
Marshal.ReleaseComObject(pWS);
if (!bCont)
{
return(false);
}
return(true);
}
catch (COMException ex)
{
MessageBox.Show(ex.Message + ": " + Convert.ToString(ex.ErrorCode));
return(false);
}
}
// TODO: swap positions of lowerEstimationLimit and upperEstimationLimit parameters
public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree tree, IRegressionProblemData problemData,
IEnumerable <int> rows, bool applyLinearScaling, int maxIterations, double upperEstimationLimit = double.MaxValue, double lowerEstimationLimit = double.MinValue, bool updateConstantsInTree = true)
{
List <AutoDiff.Variable> variables = new List <AutoDiff.Variable>();
List <AutoDiff.Variable> parameters = new List <AutoDiff.Variable>();
List <string> variableNames = new List <string>();
AutoDiff.Term func;
if (!TryTransformToAutoDiff(tree.Root.GetSubtree(0), variables, parameters, variableNames, out func))
{
throw new NotSupportedException("Could not optimize constants of symbolic expression tree due to not supported symbols used in the tree.");
}
if (variableNames.Count == 0)
{
return(0.0);
}
AutoDiff.IParametricCompiledTerm compiledFunc = AutoDiff.TermUtils.Compile(func, variables.ToArray(), parameters.ToArray());
List <SymbolicExpressionTreeTerminalNode> terminalNodes = tree.Root.IterateNodesPrefix().OfType <SymbolicExpressionTreeTerminalNode>().ToList();
double[] c = new double[variables.Count];
{
c[0] = 0.0;
c[1] = 1.0;
//extract inital constants
int i = 2;
foreach (var node in terminalNodes)
{
ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
VariableTreeNode variableTreeNode = node as VariableTreeNode;
if (constantTreeNode != null)
{
c[i++] = constantTreeNode.Value;
}
else if (variableTreeNode != null)
{
c[i++] = variableTreeNode.Weight;
}
}
}
double[] originalConstants = (double[])c.Clone();
double originalQuality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
alglib.lsfitstate state;
alglib.lsfitreport rep;
int info;
IDataset ds = problemData.Dataset;
double[,] x = new double[rows.Count(), variableNames.Count];
int row = 0;
foreach (var r in rows)
{
for (int col = 0; col < variableNames.Count; col++)
{
x[row, col] = ds.GetDoubleValue(variableNames[col], r);
}
row++;
}
double[] y = ds.GetDoubleValues(problemData.TargetVariable, rows).ToArray();
int n = x.GetLength(0);
int m = x.GetLength(1);
int k = c.Length;
alglib.ndimensional_pfunc function_cx_1_func = CreatePFunc(compiledFunc);
alglib.ndimensional_pgrad function_cx_1_grad = CreatePGrad(compiledFunc);
try {
alglib.lsfitcreatefg(x, y, c, n, m, k, false, out state);
alglib.lsfitsetcond(state, 0.0, 0.0, maxIterations);
//alglib.lsfitsetgradientcheck(state, 0.001);
alglib.lsfitfit(state, function_cx_1_func, function_cx_1_grad, null, null);
alglib.lsfitresults(state, out info, out c, out rep);
}
catch (ArithmeticException) {
return(originalQuality);
}
catch (alglib.alglibexception) {
return(originalQuality);
}
//info == -7 => constant optimization failed due to wrong gradient
if (info != -7)
{
UpdateConstants(tree, c.Skip(2).ToArray());
}
var quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
if (!updateConstantsInTree)
{
UpdateConstants(tree, originalConstants.Skip(2).ToArray());
}
if (originalQuality - quality > 0.001 || double.IsNaN(quality))
{
UpdateConstants(tree, originalConstants.Skip(2).ToArray());
return(originalQuality);
}
return(quality);
}
private void method_3(object object_0)
{
frmOpenFile file = new frmOpenFile
{
Text = "添加数据",
AllowMultiSelect = true
};
file.AddFilter(new MyGxFilterDatasets(), true);
if (file.DoModalOpen() == DialogResult.OK)
{
IFeatureClass featureClass;
IFeatureLayer layer;
System.Windows.Forms.Cursor.Current = Cursors.WaitCursor;
IArray array = new ArrayClass();
IArray items = file.Items;
int index = 0;
while (true)
{
if (index >= items.Count)
{
break;
}
IGxDataset dataset = items.get_Element(index) as IGxDataset;
if (dataset != null)
{
IDataset dataset2 = dataset.Dataset;
if (dataset2 != null)
{
if (dataset2.Type == esriDatasetType.esriDTFeatureClass)
{
featureClass = (IFeatureClass)dataset2;
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
layer = new FDOGraphicsLayerClass
{
FeatureClass = featureClass,
Name = featureClass.AliasName
};
}
else
{
layer = new FeatureLayerClass
{
FeatureClass = featureClass,
Name = featureClass.AliasName
};
}
array.Add(layer);
}
else
{
IFDOGraphicsLayerFactory factory;
if (dataset2.Type == esriDatasetType.esriDTCadDrawing)
{
IEnumGxObject children = (dataset as IGxObjectContainer).Children;
children.Reset();
for (IGxDataset dataset3 = children.Next() as IGxDataset;
dataset3 != null;
dataset3 = children.Next() as IGxDataset)
{
featureClass = dataset3.Dataset as IFeatureClass;
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
factory = new FDOGraphicsLayerFactoryClass();
layer =
(IFeatureLayer)
factory.OpenGraphicsLayer(
(IFeatureWorkspace)featureClass.FeatureDataset.Workspace,
featureClass.FeatureDataset, featureClass.AliasName);
}
else
{
layer = new FeatureLayerClass
{
FeatureClass = featureClass,
Name = featureClass.AliasName
};
}
array.Add(layer);
}
}
else if (dataset2.Type == esriDatasetType.esriDTFeatureDataset)
{
IFeatureClassContainer container = (IFeatureClassContainer)dataset2;
index = 0;
while (index < (container.ClassCount - 1))
{
featureClass = container.get_Class(index);
if (featureClass.FeatureType == esriFeatureType.esriFTAnnotation)
{
factory = new FDOGraphicsLayerFactoryClass();
layer =
(IFeatureLayer)
factory.OpenGraphicsLayer(
(IFeatureWorkspace)featureClass.FeatureDataset.Workspace,
featureClass.FeatureDataset, featureClass.AliasName);
}
else
{
layer = new FeatureLayerClass
{
FeatureClass = featureClass,
Name = featureClass.AliasName
};
}
array.Add(layer);
index++;
}
}
else if (dataset2.Type == esriDatasetType.esriDTTin)
{
ITinLayer unk = new TinLayerClass
{
Dataset = (ITin)dataset2,
Name = dataset2.Name
};
array.Add(unk);
}
else if ((dataset2.Type == esriDatasetType.esriDTRasterDataset) ||
(dataset2.Type == esriDatasetType.esriDTRasterBand))
{
bool flag = true;
if (!((IRasterPyramid)dataset2).Present)
{
if (ApplicationRef.PyramidPromptType == PyramidPromptType.AlwaysBuildNoPrompt)
{
((IRasterPyramid)dataset2).Create();
}
else if (ApplicationRef.PyramidPromptType == PyramidPromptType.AlwaysPrompt)
{
switch (BuildPyramidSet.Show())
{
case DialogResult.Yes:
((IRasterPyramid)dataset2).Create();
break;
case DialogResult.Cancel:
flag = false;
break;
}
}
}
if (flag)
{
RasterLayerClass class3 = new RasterLayerClass
{
Cached = true
};
IRasterLayer layer3 = class3;
layer3.CreateFromDataset((IRasterDataset)dataset2);
layer3.Name = dataset2.Name;
array.Add(layer3);
}
}
else if (dataset2.Type == esriDatasetType.esriDTTable)
{
try
{
IRasterCatalogTable pCatalog = new RasterCatalogTableClass
{
Table = (ITable)dataset2
};
pCatalog.Update();
IRasterCatalogLayer layer4 = new RasterCatalogLayerClass();
layer4.Create(pCatalog);
layer4.Name = dataset2.BrowseName;
array.Add(layer4);
}
catch
{
}
}
}
}
}
index++;
}
int count = array.Count;
ILayer layer5 = null;
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IRasterCatalogLayer)
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IRasterLayer)
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is ITinLayer)
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IFeatureLayer)
{
layer = layer5 as IFeatureLayer;
featureClass = layer.FeatureClass;
if ((featureClass.ShapeType == esriGeometryType.esriGeometryPolygon) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryEnvelope))
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IFeatureLayer)
{
layer = layer5 as IFeatureLayer;
featureClass = layer.FeatureClass;
if (((((featureClass.ShapeType == esriGeometryType.esriGeometryLine) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryBezier3Curve)) ||
((featureClass.ShapeType == esriGeometryType.esriGeometryCircularArc) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryEllipticArc))) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryPath)) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryPolyline))
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (layer5 is IFeatureLayer)
{
layer = layer5 as IFeatureLayer;
featureClass = layer.FeatureClass;
if ((featureClass.ShapeType == esriGeometryType.esriGeometryMultipoint) ||
(featureClass.ShapeType == esriGeometryType.esriGeometryPoint))
{
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
count--;
}
}
}
for (index = count - 1; index >= 0; index--)
{
layer5 = array.get_Element(index) as ILayer;
if (object_0 is IMap)
{
(object_0 as IMap).AddLayer(layer5);
}
else if (object_0 is IGroupLayer)
{
(object_0 as IGroupLayer).Add(layer5);
}
array.Remove(index);
}
System.Windows.Forms.Cursor.Current = Cursors.Default;
}
}
/// <summary>
/// 添加选中的图层
/// </summary>
/// <param name="pMap"></param>
/// <param name="pSuffix"></param>
/// <param name="pListCol"></param>
/// <param name="m_DatasetCol"></param>
/// <param name="pCurrentFilePath"></param>
/// <param name="blnAddData"></param>
/// <returns></returns>
public static bool AddSelectedLayer(IBasicMap pMap, string pSuffix, Collection <object> pListCol, Collection <object> m_DatasetCol, string pCurrentFilePath, bool blnAddData)
{
bool functionReturnValue = false;
System.Windows.Forms.Cursor pCursor = Cursors.Default;
//Dim pFileName As IFileName
IWorkspaceFactory pWorkspaceFactory = null;
IFeatureWorkspace pFeatWorkspace = null;
//Dim pFeatDS As IFeatureDataset
IDataset pDataset = null;
//Dim pFeatCls As IFeatureClass
IFeatureLayer pFeatLayer = null;
//Dim pLayer As ILayer
////以下三个变量是用来获得工作区的路径和文件的名称
//Dim sPath() As String
string sWorkSpacePath = pCurrentFilePath;
string sFileName = null;
if (pListCol.Count == 0)
{
return(false);
}
//要进行空间参考的比较
blnEditMapSpatial = true;
try
{
switch (pSuffix)
{
case ".shp":
{
//shp文件的处理
//获得工作区,并通过shp文件的名称打开文件
pWorkspaceFactory = new ShapefileWorkspaceFactory() as IWorkspaceFactory;
if (pWorkspaceFactory.IsWorkspace(sWorkSpacePath))
{
pFeatWorkspace = pWorkspaceFactory.OpenFromFile(sWorkSpacePath, 0) as IFeatureWorkspace;
for (int i = 0; i < pListCol.Count; i++)
{
sFileName = pListCol[i].ToString();
pDataset = pFeatWorkspace.OpenFeatureClass(sFileName) as IDataset;
m_DatasetCol.Add(pDataset);
pFeatLayer = new FeatureLayer();
//设置图层的名字和要素类
pFeatLayer.FeatureClass = pDataset as IFeatureClass;
pFeatLayer.Name = sFileName.Substring(0, sFileName.Length - 4);
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
ClsMapLayer.AddLyrToBasicMap(pMap, pFeatLayer);
ClsMapLayer.SortLayer(pMap, pFeatLayer);
}
//pSelectedCln.Add(pFeatLayer)
}
functionReturnValue = true;
}
break;
}
case "IDatasetName":
IDatasetName pDSN = null;
for (int i = 0; i < pListCol.Count; i++)
{
pDSN = pListCol[i] as IDatasetName;
functionReturnValue = ClsMapLayer.AddDataset(pMap, pDSN, m_DatasetCol, blnAddData);
}
break;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "异常", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
return(functionReturnValue);
}
//元素方式
//private void addGeometryEle(IPolygon pPolygon)
//{
// ISimpleFillSymbol pFillSymbol = new SimpleFillSymbolClass();
// ISimpleLineSymbol pLineSymbol = new SimpleLineSymbolClass();
// IPolygonElement pPolygonEle = new PolygonElementClass();
// try
// {
// //颜色对象
// IRgbColor pRGBColor = new RgbColorClass();
// pRGBColor.UseWindowsDithering = false;
// ISymbol pSymbol = (ISymbol)pFillSymbol;
// pSymbol.ROP2 = esriRasterOpCode.esriROPNotXOrPen;
// pRGBColor.Red = 255;
// pRGBColor.Green = 170;
// pRGBColor.Blue = 0;
// pLineSymbol.Color = pRGBColor;
// pLineSymbol.Width = 0.8;
// pLineSymbol.Style = esriSimpleLineStyle.esriSLSSolid;
// pFillSymbol.Outline = pLineSymbol;
// pFillSymbol.Color = pRGBColor;
// pFillSymbol.Style = esriSimpleFillStyle.esriSFSDiagonalCross;
// IElement pEle = pPolygonEle as IElement;
// pEle.Geometry = pPolygon as IGeometry;
// pEle.Geometry.SpatialReference = pPolygon.SpatialReference;
// (pEle as IFillShapeElement).Symbol = pFillSymbol;
// (pEle as IElementProperties).Name="ImpExtentOutMap";
// (m_Hook.ArcGisMapControl.Map as IGraphicsContainer).AddElement(pEle, 0);
// (m_Hook.ArcGisMapControl.Map as IActiveView).PartialRefresh(esriViewDrawPhase.esriViewGraphics, null, null);
// IGraphicsContainer pGra = m_Hook.ArcGisMapControl.Map as IGraphicsContainer;
// IActiveView pAv = pGra as IActiveView;
// pGra.Reset();
// IElement pEle2 = pGra.Next();
// while (pEle2 != null)
// {
// if ((pEle2 as IElementProperties).Name == "ImpExtentOutMap")
// {
// //pGra.DeleteElement(pEle);
// //pGra.Reset();
// }
// pEle2 = pGra.Next();
// }
// }
// catch (Exception ex)
// {
// MessageBox.Show("绘制导入范围出错:" + ex.Message, "提示");
// pFillSymbol = null;
// }
//}
#region
/// <summary>
/// 从文件路径获得一个PolyGon
/// </summary>
/// <param name="path">文件全路径</param>
/// <returns></returns>
private IPolygon GetPolyGonFromFile(string path)
{
IPolygon pGon = null;
if (path.EndsWith(".mdb"))
{
string errmsg = "";
IWorkspaceFactory pwf = new AccessWorkspaceFactoryClass();
IWorkspace pworkspace = pwf.OpenFromFile(path, 0);
IEnumDataset pEnumdataset = pworkspace.get_Datasets(esriDatasetType.esriDTFeatureClass);
pEnumdataset.Reset();
IDataset pDataset = pEnumdataset.Next();
while (pDataset != null)
{
IFeatureClass pFeatureclass = pDataset as IFeatureClass;
if (pFeatureclass.ShapeType != esriGeometryType.esriGeometryPolygon && pFeatureclass.ShapeType != esriGeometryType.esriGeometryPolyline)
{
pDataset = pEnumdataset.Next();
continue;
}
else if (pFeatureclass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
IFeatureCursor pCursor = pFeatureclass.Search(null, false);
IFeature pFeature = pCursor.NextFeature();
if (pFeature != null)
{
pGon = pFeature.Shape as IPolygon;
break;
}
else
{
pDataset = pEnumdataset.Next();
continue;
}
}
else if (pFeatureclass.ShapeType == esriGeometryType.esriGeometryPolyline)
{
IFeatureCursor pCursor = pFeatureclass.Search(null, false);
IFeature pFeature = pCursor.NextFeature();
if (pFeature != null)
{
IPolyline pPolyline = pFeature.Shape as IPolyline;
pGon = GetPolygonFormLine(pPolyline);
if (pGon.IsClosed == false)
{
errmsg = "选择的要素不能构成封闭多边形！";
pGon = null;
pDataset = pEnumdataset.Next();
continue;
}
else
{
break;
}
}
}
}
if (pGon == null)
{
IEnumDataset pEnumdataset1 = pworkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
pEnumdataset1.Reset();
pDataset = pEnumdataset1.Next();
while (pDataset != null)
{
IFeatureDataset pFeatureDataset = pDataset as IFeatureDataset;
IEnumDataset pEnumDataset2 = pFeatureDataset.Subsets;
pEnumDataset2.Reset();
IDataset pDataset1 = pEnumDataset2.Next();
while (pDataset1 != null)
{
if (pDataset1 is IFeatureClass)
{
IFeatureClass pFeatureclass = pDataset1 as IFeatureClass;
if (pFeatureclass.ShapeType != esriGeometryType.esriGeometryPolygon && pFeatureclass.ShapeType != esriGeometryType.esriGeometryPolyline)
{
pDataset1 = pEnumDataset2.Next();
continue;
}
else if (pFeatureclass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
IFeatureCursor pCursor = pFeatureclass.Search(null, false);
IFeature pFeature = pCursor.NextFeature();
if (pFeature != null)
{
pGon = pFeature.Shape as IPolygon;
break;
}
else
{
pDataset1 = pEnumDataset2.Next();
continue;
}
}
else if (pFeatureclass.ShapeType == esriGeometryType.esriGeometryPolyline)
{
IFeatureCursor pCursor = pFeatureclass.Search(null, false);
IFeature pFeature = pCursor.NextFeature();
if (pFeature != null)
{
IPolyline pPolyline = pFeature.Shape as IPolyline;
pGon = GetPolygonFormLine(pPolyline);
if (pGon.IsClosed == false)
{
errmsg = "选择的要素不能构成封闭多边形！";
pGon = null;
pDataset1 = pEnumDataset2.Next();
continue;
}
else
{
break;
}
}
}
}
}
if (pGon != null)
{
break;
}
pDataset = pEnumdataset1.Next();
}
}
if (pGon == null)
{
if (errmsg != "")
{
MessageBox.Show(errmsg, "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("请选择一个包含面要素和线要素的文件", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
return(pGon);
}
}
else if (path.EndsWith(".shp"))
{
IWorkspaceFactory pwf = new ShapefileWorkspaceFactoryClass();
string filepath = System.IO.Path.GetDirectoryName(path);
string filename = path.Substring(path.LastIndexOf("\\") + 1);
IFeatureWorkspace pFeatureworkspace = (IFeatureWorkspace)pwf.OpenFromFile(filepath, 0);
IFeatureClass pFeatureclass = pFeatureworkspace.OpenFeatureClass(filename);
if (pFeatureclass.ShapeType == esriGeometryType.esriGeometryPolygon)
{
IFeatureCursor pCursor = pFeatureclass.Search(null, false);
IFeature pFeature = pCursor.NextFeature();
if (pFeature != null)
{
pGon = pFeature.Shape as IPolygon;
}
}
else if (pFeatureclass.ShapeType == esriGeometryType.esriGeometryPolyline)
{
IFeatureCursor pCursor = pFeatureclass.Search(null, false);
IFeature pFeature = pCursor.NextFeature();
if (pFeature != null)
{
IPolyline pPolyline = pFeature.Shape as IPolyline;
pGon = GetPolygonFormLine(pPolyline);
if (pGon.IsClosed == false)
{
MessageBox.Show("选择的线要素不能构成封闭多边形！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return(null);
}
}
}
else
{
MessageBox.Show("请选择一个面或者线要素文件！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return(null);
}
}
else if (path.EndsWith(".txt"))
{
string txtpath = path;
System.IO.StreamReader smRead = new System.IO.StreamReader(txtpath, System.Text.Encoding.Default); //设置路径
string line;
pGon = new PolygonClass();
IPointCollection pc = pGon as IPointCollection;
double x, y;
while ((line = smRead.ReadLine()) != null)
{
if (line.IndexOf(",") > 0)
{
try
{
x = double.Parse(line.Substring(0, line.IndexOf(",")));
y = double.Parse(line.Substring(line.IndexOf(",") + 1));
}
catch
{
MessageBox.Show("文本文件格式不正确！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
smRead.Close();
return(null);
}
IPoint tmpPoint = new ESRI.ArcGIS.Geometry.Point();
tmpPoint.X = x;
tmpPoint.Y = y;
object ep = System.Reflection.Missing.Value;
pc.AddPoint(tmpPoint, ref ep, ref ep);
}
}
smRead.Close();
ICurve pCurve = pGon as ICurve;
if (pCurve.IsClosed == false)
{
if (pCurve.IsClosed == false)
{
//自动闭合
IPolygon2 pPolygon2 = pGon as IPolygon2;
pPolygon2.Close();
}
}
}
return(pGon);
}
public IEnumerable <double> GetEstimatedValues(IDataset dataset, IEnumerable <int> rows)
{
return(Interpreter.GetSymbolicExpressionTreeValues(SymbolicExpressionTree, dataset, rows).LimitToRange(LowerEstimationLimit, UpperEstimationLimit));
}
public LinkedFeatureClass(IDataset dataset, IFeatureClass fc, string name)
{
_dataset = dataset;
_fc = fc;
_name = name;
}
public DatasetWrap(IDataset idataset_0)
{
this.Dataset = idataset_0;
}
/// <summary>
/// 删除IDataset
/// </summary>
/// <param name="dsTarget"></param>
/// <returns></returns>
public static bool DeleteDataset(IDataset dsTarget)
{
if (dsTarget == null)
return false;
try
{
ESRI.ArcGIS.DataManagementTools.Delete gpDetele = new ESRI.ArcGIS.DataManagementTools.Delete(dsTarget);
Geoprocessor geoProcessor = new Geoprocessor();
IGeoProcessorResult gpResult = geoProcessor.Execute(gpDetele, null) as IGeoProcessorResult;
//System.Runtime.InteropServices.Marshal.FinalReleaseComObject(geoProcessor);
return gpResult.Status == esriJobStatus.esriJobSucceeded;
}
catch(Exception exp)
{
ErrorMessage = exp.Message;
return false;
}
}
public RegressionProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
: base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<ITransformation>()) {
var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
RegisterParameterEvents();
}
public static double CalculateIntraClusterSumOfSquares(KMeansClusteringModel model, IDataset dataset, IEnumerable <int> rows)
{
List <int> clusterValues = model.GetClusterValues(dataset, rows).ToList();
List <string> allowedInputVariables = model.AllowedInputVariables.ToList();
int nCols = allowedInputVariables.Count;
Dictionary <int, List <double[]> > clusterPoints = new Dictionary <int, List <double[]> >();
Dictionary <int, double[]> clusterMeans = new Dictionary <int, double[]>();
foreach (var clusterValue in clusterValues.Distinct())
{
clusterPoints.Add(clusterValue, new List <double[]>());
}
// collect points of clusters
int clusterValueIndex = 0;
foreach (var row in rows)
{
double[] p = new double[allowedInputVariables.Count];
for (int i = 0; i < nCols; i++)
{
p[i] = dataset.GetDoubleValue(allowedInputVariables[i], row);
}
clusterPoints[clusterValues[clusterValueIndex++]].Add(p);
}
// calculate cluster means
foreach (var pair in clusterPoints)
{
double[] mean = new double[nCols];
foreach (var p in pair.Value)
{
for (int i = 0; i < nCols; i++)
{
mean[i] += p[i];
}
}
for (int i = 0; i < nCols; i++)
{
mean[i] /= pair.Value.Count;
}
clusterMeans[pair.Key] = mean;
}
// calculate distances
double allCenterDistances = 0;
foreach (var pair in clusterMeans)
{
double[] mean = pair.Value;
double centerDistances = 0;
foreach (var clusterPoint in clusterPoints[pair.Key])
{
double centerDistance = 0;
for (int i = 0; i < nCols; i++)
{
double d = mean[i] - clusterPoint[i];
d = d * d;
centerDistance += d;
}
centerDistances += centerDistance;
}
allCenterDistances += centerDistances;
}
return(allCenterDistances);
}
public bool UpdateParcelRecordsByPlanGroup(ITable pParcelsTable, ArrayList sParcelUpdates,
Dictionary <string, int> TheNewPlanIDs, Dictionary <int, int> ParcelLookup, bool bUseNonVersionedEdit,
IStepProgressor m_pStepProgressor, ITrackCancel TrackCancel)
{
bool bShowProgressor = (m_pStepProgressor != null && TrackCancel != null);
if (bShowProgressor)
{
m_pStepProgressor.Message = "Updating Parcels...";
}
Int32 iPlanID = pParcelsTable.Fields.FindField("PLANID");
IDataset pDS = (IDataset)pParcelsTable;
ISQLSyntax pSQLSyntax = (ISQLSyntax)pDS.Workspace;
string sPref = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
string sSuff = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
IQueryFilter pQF = new QueryFilterClass();
string FieldName = pParcelsTable.OIDFieldName;
bool bCont = true;
try
{
foreach (string InClause in sParcelUpdates)
{
if (InClause.Trim() == "")
{
continue;
}
pQF.WhereClause = sPref + FieldName + sSuff + " IN (" + InClause + ")";
ITableWrite2 pParcelsTableWr = (ITableWrite2)pParcelsTable;
ICursor pUpdateCur = null;
if (bUseNonVersionedEdit)
{
pUpdateCur = pParcelsTableWr.UpdateRows(pQF, false);
}
else
{
pUpdateCur = pParcelsTable.Update(pQF, false);
}
IRow pRow = pUpdateCur.NextRow();
//now update the parcel planid
int iOldPlanID = -1;
int iNewPlanID = -1;
while (pRow != null)
{
int iParcelID = pRow.OID;
if (!ParcelLookup.TryGetValue(iParcelID, out iOldPlanID))
{
continue;
}
string sNewPlanName = "[" + Convert.ToString(iOldPlanID) + "]";
if (!TheNewPlanIDs.TryGetValue(sNewPlanName, out iNewPlanID))
{
continue;
}
pRow.set_Value(iPlanID, iNewPlanID);
pUpdateCur.UpdateRow(pRow);
if (bShowProgressor)
{
if (m_pStepProgressor.Position < m_pStepProgressor.MaxRange)
{
m_pStepProgressor.Step();
}
}
Marshal.ReleaseComObject(pRow);
//after garbage collection, and before gettng the next row,
//check if the cancel button was pressed. If so, stop process
if (bShowProgressor)
{
bCont = TrackCancel.Continue();
}
if (!bCont)
{
break;
}
pRow = pUpdateCur.NextRow();
}
if (pUpdateCur != null)
{
Marshal.ReleaseComObject(pUpdateCur);
}
if (!bCont)
{
break;
}
}
}
catch (COMException Ex)
{
MessageBox.Show("Problem encountered:" + Ex.ErrorCode.ToString() + ":" + Ex.Message,
"Update Parcel Records");
if (pQF != null)
{
Marshal.ReleaseComObject(pQF);
}
return(false);
}
if (pQF != null)
{
Marshal.ReleaseComObject(pQF);
}
return(bCont); //return the result from the Cancel tracker...true unless cancel was clicked.
}
public static bool AddDataset(IBasicMap pBasicMap, IDatasetName pDatasetName, Collection <object> m_DatasetCol, bool blnAddData)
{
bool functionReturnValue = false;
functionReturnValue = false;
////如果是特征数据集,则添加里边的所有要素类
IFeatureDataset pFeatDS = default(IFeatureDataset);
IEnumDataset pEnumDataSet = default(IEnumDataset);
IDataset pDataset = default(IDataset);
IFeatureClass pFeatCls = default(IFeatureClass);
IFeatureLayer pFeatLayer = default(IFeatureLayer);
IName pName = default(IName);
ILayer pLayer = default(ILayer);
ITopologyLayer pTopoLayer = default(ITopologyLayer);
//Dim pEnumLyr As IEnumLayer
ITinWorkspace pTinWS = default(ITinWorkspace);
IEnumFeatureClass pEnumFeatCls = null;
IRasterCatalogDisplayProps pRasterCatalogPro = default(IRasterCatalogDisplayProps);
//ClsErrorHandle pfrmError = new ClsErrorHandle();
//ClsLayerRender pLayerRender = null;
if (pDatasetName is IFeatureDatasetName)
{
pName = pDatasetName as IName;
pFeatDS = pName.Open() as IFeatureDataset;
pEnumDataSet = pFeatDS.Subsets;
pDataset = pEnumDataSet.Next();
m_DatasetCol.Add(pDataset);
if (pDataset == null)
{
return(false);
}
////根据数据集的类型,添加特征数据集中的所有要素类(拓扑,一般的,栅格目录,网络)
while ((pDataset != null))
{
if (pDataset.Type == esriDatasetType.esriDTFeatureClass)
{
//pLayerRender = new ClsLayerRender();
//// 陈昉 2008-12-3 修改 修改原因 添加SDE图层时从数据库读取符号化信息
//pFeatLayer = null;
//if (pDataset.Workspace.Type == esriWorkspaceType.esriRemoteDatabaseWorkspace)
//{
// pFeatLayer = pLayerRender.GetRendererLayer((IFeatureClass)pDataset);
//}
if (pFeatLayer == null)
{
pFeatLayer = new FeatureLayer();
pFeatCls = pDataset as IFeatureClass;
pFeatLayer.Name = pFeatCls.AliasName;
pFeatLayer.FeatureClass = pFeatCls;
}
if (pDataset.Type == esriDatasetType.esriDTRasterCatalog)
{
// Dim pRaster
}
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
// pSelectedCln.Add(pFeatLayer)
}
else if (pDataset.Type == esriDatasetType.esriDTTopology)
{
pTopoLayer = new TopologyLayer() as ITopologyLayer;
pTopoLayer.Topology = pDataset as ITopology;
pLayer = pTopoLayer as ILayer;
pLayer.Name = pDataset.Name;
if (blnAddData == true)
{
//pMap.AddLayer pLayer
AddLyrToBasicMap(pBasicMap, pLayer);
SortLayer(pBasicMap, pLayer);
}
//pSelectedCln.Add(pFeatLayer)
}
pDataset = pEnumDataSet.Next();
}
functionReturnValue = true;
////添加拓扑图层
}
else if (pDatasetName is ITopologyName)
{
ITopology pTopo = null;
pName = pDatasetName as IName;
pDataset = pName.Open() as IDataset;
pTopoLayer = new TopologyLayer() as ITopologyLayer;
pTopoLayer.Topology = pDataset as ITopology;
pLayer = pTopoLayer as ILayer;
pLayer.Name = pDataset.Name;
m_DatasetCol.Add(pDataset);
if (blnAddData == true)
{
//pMap.AddLayer pLayer
AddLyrToBasicMap(pBasicMap, pLayer);
SortLayer(pBasicMap, pLayer);
}
//pSelectedCln.Add(pLayer)
if (MessageBox.Show("要把拓扑里边的所有要素类也添加到当前地图中吗?", "提示", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
== DialogResult.Yes)
{
IFeatureClassContainer pFeatClsContainer = default(IFeatureClassContainer);
pFeatClsContainer = pTopo as IFeatureClassContainer;
pEnumFeatCls = pFeatClsContainer.Classes;
pFeatCls = pEnumFeatCls.Next();
pFeatLayer = new FeatureLayer();
////循环拓扑中的每个要素类,并添加到当前地图中
while ((pFeatCls != null))
{
pFeatLayer.FeatureClass = pFeatCls;
pFeatLayer.Name = pFeatCls.AliasName;
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
//pSelectedCln.Add(pFeatLayer)
pFeatCls = pEnumFeatCls.Next();
}
}
functionReturnValue = true;
////添加网络数据
}
else if (pDatasetName is IGeometricNetworkName)
{
INetworkCollection pNetworkCollection = default(INetworkCollection);
IGeometricNetwork pGeometricNetwork = default(IGeometricNetwork);
IDataset pGeoDataset = default(IDataset);
pName = pDatasetName as IName;
pGeoDataset = pName.Open() as IDataset;
m_DatasetCol.Add(pGeoDataset);
if (pGeoDataset.Type == esriDatasetType.esriDTGeometricNetwork)
{
////这里对网络数据进行处理
IFeatureClassContainer pFeatureClassContainer = null;
pGeometricNetwork = pGeoDataset as IGeometricNetwork;
pFeatureClassContainer = pGeometricNetwork as IFeatureClassContainer;
for (int i = 0; i < pFeatureClassContainer.ClassCount; i++)
{
pFeatCls = pFeatureClassContainer.get_Class(i);
pFeatLayer = new FeatureLayer();
pFeatLayer.Name = pFeatCls.AliasName;
pFeatLayer.FeatureClass = pFeatCls;
if (blnAddData == true)
{
// pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
//pSelectedCln.Add(pFeatLayer)
}
}
else
{
pFeatDS = pGeoDataset as IFeatureDataset;
pNetworkCollection = pFeatDS as INetworkCollection;
////如果是用户选择一个网络技术打开的话,肯定只有一个网络在里边,其实
////可以不需要循环,而用GeometricNetwork(0)代替循环
for (int j = 0; j < pNetworkCollection.GeometricNetworkCount; j++)
{
pGeometricNetwork = pNetworkCollection.get_GeometricNetwork(j);
for (int i = 0; i <= 3; i++)
{
switch (i)
{
case 0:
pEnumFeatCls = pGeometricNetwork.get_ClassesByType(esriFeatureType.esriFTSimpleJunction);
break;
case 1:
pEnumFeatCls = pGeometricNetwork.get_ClassesByType(esriFeatureType.esriFTSimpleEdge);
break;
case 2:
pEnumFeatCls = pGeometricNetwork.get_ClassesByType(esriFeatureType.esriFTComplexJunction);
break;
case 3:
pEnumFeatCls = pGeometricNetwork.get_ClassesByType(esriFeatureType.esriFTComplexEdge);
break;
}
pFeatCls = pEnumFeatCls.Next();
while ((pFeatCls != null))
{
pFeatLayer = new FeatureLayer();
pFeatLayer.Name = pFeatCls.AliasName;
pFeatLayer.FeatureClass = pFeatCls;
pFeatCls = pEnumFeatCls.Next();
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
// pSelectedCln.Add(pFeatLayer)
functionReturnValue = true;
}
}
}
}
////添加栅格目录，并设置为显示最新时相
}
else if (pDatasetName is IRasterCatalogName)
{
pName = pDatasetName as IName;
pDataset = pName.Open() as IDataset;
m_DatasetCol.Add(pDataset);
pFeatLayer = new GdbRasterCatalogLayer() as IFeatureLayer;
pFeatLayer.FeatureClass = pDataset as IFeatureClass;
pFeatLayer.Name = pDataset.Name;
//'//如果是SDE的栅格目录
//If pFeatLayer.DataSourceType = "SDE Raster Catalog" Then
// Dim pFeatLayerDef As IFeatureLayerDefinition
// pFeatLayerDef = pFeatLayer
// '//设置最初显示地图范围内最近时相的数据
// pFeatLayerDef.DefinitionExpression = "objectid in (select objectid from" & vbNewLine & _
// "(select a.objectid, b.receive_date,rank()" & vbNewLine & _
// "over(partition by a.name,a.resolution order by b.receive_date desc) as cid" & vbNewLine & _
// "from " & pFeatLayer.Name & " a, sj_t_tense b" & vbNewLine & _
// "where a.tense = b.tense" & vbNewLine & "and b.online_state = 1) t2" & vbNewLine & _
// "where " & pFeatLayer.Name & ".objectid=t2.objectid and t2.cid = 1)"
//End If
////设置当栅格目录中的图幅在地图上超过16个的时候，以格网来显示，而不显示栅格本身
pRasterCatalogPro = pFeatLayer as IRasterCatalogDisplayProps;
////不用数量来控制了,而以比例尺来控制
pRasterCatalogPro.DisplayRasters = 16;
pRasterCatalogPro.UseScale = true;
////设置一个比例,在此临界栅格数据将会在框架显示与实际栅格显示之间转换
pRasterCatalogPro.TransitionScale = 50000;
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
//SortLayer(pBasicMap, pFeatLayer)
}
//pSelectedCln.Add(pFeatLayer)
functionReturnValue = true;
}
else if (pDatasetName is IRasterDatasetName)
{
IRasterLayer pRasterLayer = default(IRasterLayer);
pName = pDatasetName as IName;
pDataset = pName.Open() as IDataset;
m_DatasetCol.Add(pDataset);
pRasterLayer = new RasterLayer();
pRasterLayer.CreateFromDataset((IRasterDataset)pDataset);
pRasterLayer.Name = pDataset.Name;
AddLyrToBasicMap(pBasicMap, pRasterLayer);
functionReturnValue = true;
////添加TIN图层
}
else if (pDatasetName is ITinWorkspace)
{
pTinWS = pDatasetName as ITinWorkspace;
ITinLayer pTinLyr = default(ITinLayer);
pTinLyr = new TinLayer();
pTinLyr.Dataset = pTinWS.OpenTin(pDatasetName.Name);
pTinLyr.Name = pDatasetName.Name;
if (blnAddData == true)
{
//pMap.AddLayer pTinLyr
AddLyrToBasicMap(pBasicMap, pTinLyr);
SortLayer(pBasicMap, pTinLyr);
}
//pSelectedCln.Add(pTinLyr)
functionReturnValue = true;
}
else if (pDatasetName is INetworkDatasetName)
{
//Dim pNetWorkDS As INetworkDataset
try
{
INetworkLayer pNetLayer = default(INetworkLayer);
pName = pDatasetName as IName;
pNetLayer = new NetworkLayer() as INetworkLayer;
pNetLayer.NetworkDataset = pName.Open() as INetworkDataset;
pLayer = pNetLayer as ILayer;
pLayer.Name = pName.NameString;
if (blnAddData == true)
{
AddLyrToBasicMap(pBasicMap, pLayer);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "异常", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
////添加一般的要素类,未写完。。。。。。
}
else
{
pName = pDatasetName as IName;
pDataset = pName.Open() as IDataset;
pFeatCls = pDataset as IFeatureClass;
m_DatasetCol.Add(pDataset);
if (pFeatCls.FeatureType == esriFeatureType.esriFTAnnotation)
{
pFeatLayer = new FDOGraphicsLayer() as IFeatureLayer;
}
else if (pFeatCls.FeatureType == esriFeatureType.esriFTDimension)
{
pFeatLayer = new DimensionLayer() as IFeatureLayer;
}
else
{
pFeatLayer = new FeatureLayer();
//pLayerRender = new ClsLayerRender();
//// 陈昉 2008-12-3 修改 修改原因 添加SDE图层时从数据库读取符号化信息
//if (pDataset.Workspace.Type == esriWorkspaceType.esriRemoteDatabaseWorkspace)
//{
// pFeatLayer = pLayerRender.GetRendererLayer((IFeatureClass)pDataset);
//}
}
//印骅 20081205 添加"Not"
if ((pFeatLayer != null))
{
//pFeatLayer.Name = pDataset.Name
pFeatLayer.Name = pFeatCls.AliasName;
pFeatLayer.FeatureClass = pDataset as IFeatureClass;
}
if (blnAddData == true)
{
//pMap.AddLayer pFeatLayer
AddLyrToBasicMap(pBasicMap, pFeatLayer);
SortLayer(pBasicMap, pFeatLayer);
}
//pSelectedCln.Add(pFeatLayer)
functionReturnValue = true;
}
return(functionReturnValue);
//'//添加Coverage图层
//ElseIf vItem.SmallIcon = "Coverage" Then
//AddSelectedLayer = ADDCoverageLayer(pMap, pCurrentFilePath.Path, _
//vItem.Text, pSelectedCln, blnAddData)
}
//在指定文件目录下新建并获取要素类
public IFeatureClass getFeatureClass(string shpPath)
{
//确定存放shapefile的文件路径是否存在
string strShapeFolder = shpPath;
string strShapeFile = "contourPolygon.shp";
FileInfo fFile = new FileInfo(strShapeFolder + @"\" + strShapeFile);
//是否重命名
if (fFile.Exists)
{
DialogResult r2 = MessageBox.Show("此文件名已经被覆盖", "返回值是0否1", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
//取消关闭
if (r2 == System.Windows.Forms.DialogResult.Yes)
{
DirectoryInfo fold = new DirectoryInfo(strShapeFolder);
FileInfo[] files = fold.GetFiles("contourPolygon" + ".*");
foreach (FileInfo f in files)
{
f.Delete();
}
}
}
string sFileFullName = strShapeFolder + strShapeFile;
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactory();
IFeatureWorkspace pFeatureWorkspace = (IFeatureWorkspace)pWorkspaceFactory.OpenFromFile(strShapeFolder, 0);
IFeatureClass pFeatureClass = null;
if (File.Exists(sFileFullName))
{
pFeatureClass = pFeatureWorkspace.OpenFeatureClass(strShapeFile);
IDataset pDataset = (IDataset)pFeatureClass;
pDataset.Delete();
}
//创建字段
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
IField pField = new FieldClass();
IFieldEdit pFieldEdit = (IFieldEdit)pField;
ISpatialReferenceFactory spatialReferenceFac = new SpatialReferenceEnvironment();
IGeographicCoordinateSystem pGCS;
//pGCS = spatialReferenceFac.CreateGeographicCoordinateSystem();
pFieldEdit.Name_2 = "SHAPE";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDefEdit pGeoDef = new GeometryDefClass();
IGeometryDefEdit pGeoDefEdit = (IGeometryDefEdit)pGeoDef;
pGeoDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolygon;
pGeoDefEdit.SpatialReference_2 = new UnknownCoordinateSystemClass();
pFieldEdit.GeometryDef_2 = pGeoDef;
pFieldsEdit.AddField(pField);
//创建shp
pFeatureClass = pFeatureWorkspace.CreateFeatureClass(strShapeFile, pFields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
return(pFeatureClass);
}
//---------------------------------------------------------------------
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="path">
/// Path to the raster file that represents the map.
/// </param>
/// <param name="ecoregions">Dataset of ecoregions</param>
public Map(string path,
IDataset ecoregions)
{
this.path = path;
this.ecoregions = ecoregions;
}
private IFeatureLayer DissolveLineLayer(IFeatureLayer InFeatureLayer)
{
try{
ITable dissolveTable = (ITable)InFeatureLayer;
IDataset dataset = (IDataset)InFeatureLayer;
ESRI.ArcGIS.Geoprocessor.Geoprocessor geoprocessor = new ESRI.ArcGIS.Geoprocessor.Geoprocessor();
ESRI.ArcGIS.DataManagementTools.Dissolve d = new ESRI.ArcGIS.DataManagementTools.Dissolve();
d.in_features = dissolveTable;
d.out_feature_class = System.IO.Path.Combine(dataset.Workspace.PathName, "doodie");
d.dissolve_field = "SHAPE";
//d.statistics_fields = "";
d.multi_part = "MULTI_PART";
geoprocessor.Execute(d, null);
return(d.out_feature_class as IFeatureLayer);
//ESRI.ArcGIS.Geoprocessor.Geoprocessor geoprocessor = new ESRI.ArcGIS.Geoprocessor.Geoprocessor();
//ESRI.ArcGIS.DataManagementTools.Dissolve d = new ESRI.ArcGIS.DataManagementTools.Dissolve();
//ESRI.ArcGIS.Geoprocessing.IGeoProcessorResult Result;
//IFeatureLayer pOutFeatureLayer = new FeatureLayer();
//try
//{
// geoprocessor.AddOutputsToMap = false;
// geoprocessor.OverwriteOutput = true;
// d.in_features = InFeatureLayer.Name ;
// d.dissolve_field = InFeatureLayer.FeatureClass.ShapeFieldName;
// d.out_feature_class = "Dissolve";
// Result = geoprocessor.Execute(d, null) as IGeoProcessorResult;
// pOutFeatureLayer.FeatureClass = geoprocessor.Open("Dissolve") as IFeatureClass;
// return pOutFeatureLayer;
//IFeatureLayer OutFeatureLayer = new FeatureLayer();
//IGxCatalogDefaultDatabase Defaultgdb = ArcMap.Application as IGxCatalogDefaultDatabase;
//string g = Defaultgdb.DefaultDatabaseName.PathName;
//ITable dissolveTable = (ITable)InFeatureLayer;
//IDataset dataset = (IDataset)InFeatureLayer;
//ESRI.ArcGIS.Geoprocessor.Geoprocessor geoprocessor = new ESRI.ArcGIS.Geoprocessor.Geoprocessor();
//ESRI.ArcGIS.DataManagementTools.Dissolve d = new ESRI.ArcGIS.DataManagementTools.Dissolve();
//d.in_features = dissolveTable;
//d.out_feature_class = Defaultgdb.DefaultDatabaseName.PathName + "\\diss";
//d.dissolve_field = InFeatureLayer.FeatureClass.ShapeFieldName;
////d.statistics_fields = "";
////d.multi_part = "MULTI_PART";
//geoprocessor.Execute(d, null);
//OutFeatureLayer.FeatureClass = d.out_feature_class as IFeatureClass;
//return OutFeatureLayer;
////return d.out_feature_class as IFeatureClass;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
MessageBox.Show(ex.StackTrace);
return(null);
}
}
public static IFeatureClass exportDataToMemery(List <Dictionary <string, object> > dicExportData, IFeatureClass memoryFeaClsOfIntersect, ISpatialReference pSpatialReference,
out string msg)
{
msg = string.Empty;
IWorkspaceEdit pWorkapceEdit = null;
IFeatureBuffer pTargetFeatureBuffer = null;
IFeatureCursor pTargetFeatureCursor = null;
try
{
IDataset dataset = memoryFeaClsOfIntersect as IDataset;
pWorkapceEdit = dataset.Workspace as IWorkspaceEdit;
pWorkapceEdit.StartEditing(false);
pWorkapceEdit.StartEditOperation();
pTargetFeatureBuffer = memoryFeaClsOfIntersect.CreateFeatureBuffer();
pTargetFeatureCursor = memoryFeaClsOfIntersect.Insert(true);
IFields fieldsSource = memoryFeaClsOfIntersect.Fields; //插入
// fieldsSource.
foreach (var item in dicExportData)
{
foreach (var key in item.Keys)
{
int i = fieldsSource.FindField(key);
if (string.Equals(key, "geometry"))
{
pTargetFeatureBuffer.Shape = (IGeometry)item[key];
}
if (i > -1)
{
if (fieldsSource.Field[i].Type == esriFieldType.esriFieldTypeOID || fieldsSource.Field[i].Type == esriFieldType.esriFieldTypeGeometry)
{
continue;
}
if (item[key] != null)
{
pTargetFeatureBuffer.Value[i] = item[key];
}
}
}
pTargetFeatureCursor.InsertFeature(pTargetFeatureBuffer);
}
pTargetFeatureCursor.Flush();
pWorkapceEdit.StopEditOperation();
pWorkapceEdit.StopEditing(true);
}
catch (Exception e)
{
msg = e.Data + e.HelpLink + e.HResult + e.InnerException + e.Message + e.Source;
}
finally
{
if (pWorkapceEdit != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(pWorkapceEdit);
}
if (pTargetFeatureBuffer != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(pTargetFeatureBuffer);
}
if (pTargetFeatureCursor != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(pTargetFeatureCursor);
}
}
return(memoryFeaClsOfIntersect);
}
/// <summary>
/// 从mdb到vct转换时，初始化图层列表
/// </summary>
private bool InitialFeatureList()
{
try
{
if (m_pIDataset == null)
return false;
m_FeatureList = new List<TableLayer>();
IEnumDataset pEnumDataset = m_pIDataset.Subsets;
IDataset pSet = pEnumDataset.Next();
while (pSet != null)
{
FeatureLayer pFeatureLayer = null;
IFeatureClass pFeatureCls = pSet as IFeatureClass;
string sGeometryType = "";
///从配置文件获取要素类型
Metadata.MetaTable pMetaTable = Metadata.MetaDataFile.MetaTabls[pSet.Name] as Metadata.MetaTable;
if (pMetaTable != null)
{
sGeometryType = pMetaTable.Type;
}
else
{
///如果不属于标准的数据则不处理
pSet = pEnumDataset.Next();
continue;
}
///根据要素类型创建vct空间数据节点
esriGeometryType pFeatureType = pFeatureCls.ShapeType;
if (pFeatureType == esriGeometryType.esriGeometryLine
|| pFeatureType == esriGeometryType.esriGeometryPolyline)
{
///构造线节点
pFeatureLayer = new LineLayer();
if (sGeometryType == "")
sGeometryType = "Line";
}
else if (pFeatureType == esriGeometryType.esriGeometryPolygon)
{
//构造面节点
pFeatureLayer = new PolygonLayer();
if (sGeometryType == "")
sGeometryType = "Polygon";
}
else if (pFeatureType == esriGeometryType.esriGeometryPoint)
{
pFeatureLayer = new PointLayer();
if (sGeometryType == "")
sGeometryType = "Point";
}
////注记图层
if (pFeatureCls.FeatureType == esriFeatureType.esriFTAnnotation)
{
pFeatureLayer = new AnnotationLayer();
pFeatureLayer.GeometryType = "Annotation";
}
pFeatureLayer.CutGeometry =m_cutGeometry;
//挂接空间数据表
pFeatureLayer.Table = pSet as ITable;
pFeatureLayer.GeometryType = sGeometryType;
pFeatureLayer.IsCut = m_bCut;
pFeatureLayer.FeatureCode = MetaDataFile.GetFeatureCodeByName(pSet.Name);
pFeatureLayer.UpdateFieldIndex();
m_FeatureList.Add(pFeatureLayer);
pSet = pEnumDataset.Next();
}
///处理属性表集合
IEnumDataset pAttriTalbelDataSet= m_pIWorkspace.get_Datasets(esriDatasetType.esriDTTable);
IDataset pAttriDataset = pAttriTalbelDataSet.Next();
while (pAttriDataset != null)
{
TableLayer pAttributeTalbe = new TableLayer();
///从配置文件获取要素类型
Metadata.MetaTable pMetaTable = Metadata.MetaDataFile.MetaTabls[pAttriDataset.Name] as Metadata.MetaTable;
if (pMetaTable != null)
{
pAttributeTalbe.GeometryType = pMetaTable.Type;
pAttributeTalbe.Table = pAttriDataset as ITable;
pAttributeTalbe.UpdateFieldIndex();
m_FeatureList.Add(pAttributeTalbe);
}
pAttriDataset = pAttriTalbelDataSet.Next();
}
return true;
}
catch (Exception ex)
{
LogAPI.WriteErrorLog(ex);
return false;
}
}
/// <summary>
/// 拷贝源图层到空间数据集下的目标图层
/// </summary>
/// <param name="sourceWorkspace">源Workspace</param>
/// <param name="targetWorkspace">目标Workspace</param>
/// <param name="sourceClassName">源图层</param>
/// <param name="destClassName">待创建的图层名</param>
public static bool ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace,
string sourceClassName, string destClassName)
{
try
{
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = sourceClassName;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = destClassName;
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField = targetFeatureClassFields.get_Field(targetFeatureClassFields.FindField(sourceFeatureClass.ShapeFieldName));
//for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
//{
// geometryField = targetFeatureClassFields.get_Field(i);
// if (geometryField.Type == esriFieldType.esriFieldTypeGeometry)
// {
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IEnumDataset pEnumDataset = targetWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertFeatureClass(sourceFeatureClassName, queryFilter,
null, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
IInvalidObjectInfo obj = enumErrors.Next();
// break;
// }
//}
return(true);
}
catch (Exception exp)
{
return(false);
}
}
/// <summary> /// Adds a dataset to the end of the <see cref="BarDatasetCollection"/>. /// </summary> /// <param name="dataset"> /// The dataset to be added to the end of the <see cref="BarDatasetCollection"/>. /// The value can't be null. /// </param> public void Add(IDataset <TimePoint> dataset) => AddDataset(dataset);
/// <summary>
/// 拷贝源表到目标空间
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="SourceDataset"></param>
/// <param name="nameOfTargetDataset"></param>
public static bool ConvertTable(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, IDataset SourceDataset,
string nameOfTargetDataset)
{
try
{
ITable pSourceTab = (ITable)SourceDataset;
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IDatasetName sourceDatasetName = (IDatasetName)SourceDataset.FullName;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
ITableName targetTableName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetTableName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetDataset;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFields;
IFields sourceFields = pSourceTab.Fields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError == null)
{
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertTable(sourceDatasetName, queryFilter, targetDatasetName, pSourceTab.Fields, "",
1000, 0);
}
return(true);
}
catch (Exception exp)
{
return(false);
}
}
public static IEnumerable <int> FindClosestCenters(IEnumerable <double[]> centers, IDataset dataset, IEnumerable <string> allowedInputVariables, IEnumerable <int> rows)
{
int nRows = rows.Count();
int nCols = allowedInputVariables.Count();
int[] closestCenter = new int[nRows];
double[] bestCenterDistance = Enumerable.Repeat(double.MaxValue, nRows).ToArray();
int centerIndex = 1;
foreach (double[] center in centers)
{
if (nCols != center.Length)
{
throw new ArgumentException();
}
int rowIndex = 0;
foreach (var row in rows)
{
// calc euclidian distance of point to center
double centerDistance = 0;
int col = 0;
foreach (var inputVariable in allowedInputVariables)
{
double d = center[col++] - dataset.GetDoubleValue(inputVariable, row);
d = d * d; // square;
centerDistance += d;
if (centerDistance > bestCenterDistance[rowIndex])
{
break;
}
}
if (centerDistance < bestCenterDistance[rowIndex])
{
bestCenterDistance[rowIndex] = centerDistance;
closestCenter[rowIndex] = centerIndex;
}
rowIndex++;
}
centerIndex++;
}
return(closestCenter);
}
public NearestNeighbourModel(IDataset dataset, IEnumerable <int> rows, int k, string targetVariable, IEnumerable <string> allowedInputVariables, IEnumerable <double> weights = null, double[] classValues = null)
: base(targetVariable)
{
Name = ItemName;
Description = ItemDescription;
this.k = k;
this.allowedInputVariables = allowedInputVariables.ToArray();
double[,] inputMatrix;
if (IsCompatibilityLoaded)
{
// no scaling
inputMatrix = dataset.ToArray(
this.allowedInputVariables.Concat(new string[] { targetVariable }),
rows);
}
else
{
this.offsets = this.allowedInputVariables
.Select(name => dataset.GetDoubleValues(name, rows).Average() * -1)
.Concat(new double[] { 0 }) // no offset for target variable
.ToArray();
if (weights == null)
{
// automatic determination of weights (all features should have variance = 1)
this.weights = this.allowedInputVariables
.Select(name => 1.0 / dataset.GetDoubleValues(name, rows).StandardDeviationPop())
.Concat(new double[] { 1.0 }) // no scaling for target variable
.ToArray();
}
else
{
// user specified weights (+ 1 for target)
this.weights = weights.Concat(new double[] { 1.0 }).ToArray();
if (this.weights.Length - 1 != this.allowedInputVariables.Length)
{
throw new ArgumentException("The number of elements in the weight vector must match the number of input variables");
}
}
inputMatrix = CreateScaledData(dataset, this.allowedInputVariables.Concat(new string[] { targetVariable }), rows, this.offsets, this.weights);
}
if (inputMatrix.Cast <double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
{
throw new NotSupportedException(
"Nearest neighbour model does not support NaN or infinity values in the input dataset.");
}
this.kdTree = new alglib.nearestneighbor.kdtree();
var nRows = inputMatrix.GetLength(0);
var nFeatures = inputMatrix.GetLength(1) - 1;
if (classValues != null)
{
this.classValues = (double[])classValues.Clone();
int nClasses = classValues.Length;
// map original class values to values [0..nClasses-1]
var classIndices = new Dictionary <double, double>();
for (int i = 0; i < nClasses; i++)
{
classIndices[classValues[i]] = i;
}
for (int row = 0; row < nRows; row++)
{
inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
}
}
alglib.nearestneighbor.kdtreebuild(inputMatrix, nRows, inputMatrix.GetLength(1) - 1, 1, 2, kdTree);
}
public AXLFeatureLayer(IDataset parent)
{
m_parent = parent;
}
//复制GDB数据
public static void CopyPasteGeodatabaseData(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, string objectName, esriDatasetType esriDataType)
{
// Validate input
if ((sourceWorkspace.Type == esriWorkspaceType.esriFileSystemWorkspace) || (targetWorkspace.Type == esriWorkspaceType.esriFileSystemWorkspace))
{
return; // Should be a throw
}
//create source workspace name
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//Create Name Object Based on data type
IDatasetName datasetName;
switch (esriDataType)
{
case esriDatasetType.esriDTFeatureDataset:
IFeatureDatasetName inFeatureDatasetName = new FeatureDatasetNameClass();
datasetName = (IDatasetName)inFeatureDatasetName;
break;
case esriDatasetType.esriDTFeatureClass:
IFeatureClassName inFeatureClassName = new FeatureClassNameClass();
datasetName = (IDatasetName)inFeatureClassName;
break;
case esriDatasetType.esriDTTable:
ITableName inTableName = new TableNameClass();
datasetName = (IDatasetName)inTableName;
break;
case esriDatasetType.esriDTGeometricNetwork:
IGeometricNetworkName inGeometricNetworkName = new GeometricNetworkNameClass();
datasetName = (IDatasetName)inGeometricNetworkName;
break;
case esriDatasetType.esriDTRelationshipClass:
IRelationshipClassName inRelationshipClassName = new RelationshipClassNameClass();
datasetName = (IDatasetName)inRelationshipClassName;
break;
case esriDatasetType.esriDTNetworkDataset:
INetworkDatasetName inNetworkDatasetName = new NetworkDatasetNameClass();
datasetName = (IDatasetName)inNetworkDatasetName;
break;
case esriDatasetType.esriDTTopology:
ITopologyName inTopologyName = new TopologyNameClass();
datasetName = (IDatasetName)inTopologyName;
break;
default:
return; // Should be a throw
}
// Set the name of the object to be copied
datasetName.WorkspaceName = (IWorkspaceName)sourceWorkspaceName;
datasetName.Name = objectName;
//Setup mapping for copy/paste
IEnumNameMapping fromNameMapping;
ESRI.ArcGIS.esriSystem.IEnumNameEdit editFromName;
ESRI.ArcGIS.esriSystem.IEnumName fromName = new NamesEnumerator();
editFromName = (ESRI.ArcGIS.esriSystem.IEnumNameEdit)fromName;
editFromName.Add((ESRI.ArcGIS.esriSystem.IName)datasetName);
ESRI.ArcGIS.esriSystem.IName toName = (ESRI.ArcGIS.esriSystem.IName)targetWorkspaceName;
// Generate name mapping
ESRI.ArcGIS.Geodatabase.IGeoDBDataTransfer geoDBDataTransfer = new GeoDBDataTransferClass();
bool targetWorkspaceExists;
targetWorkspaceExists = geoDBDataTransfer.GenerateNameMapping(fromName, toName, out fromNameMapping);
// Copy/Pate the data
geoDBDataTransfer.Transfer(fromNameMapping, toName);
}
public IFeatureClass IfeatureBuffer(List <IPoint> contourPoint, IFeatureClass featureclass, String contour)
{
if (featureclass.ShapeType != ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolygon)
{
return(null);
}
//根据数据集得到工作空间
IDataset dataset = (IDataset)featureclass;
IWorkspace workspace = dataset.Workspace;
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)workspace;
// 开始数据编辑和数据操作
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
//创建Feature Buffer
IFeatureBuffer featureBuffer = featureclass.CreateFeatureBuffer();
// 创建插入游标并设置buffering为true
IFeatureCursor featurecursor = featureclass.Insert(true);
object featureOID;
//构造面，并将构成等高线的点赋予面
IPoint pPoint = new PointClass();
IPointCollection pointCollection = new PolygonClass();
object missing = Type.Missing;
double x, y;
for (int i = 0; i < contourPoint.Count; i++)
{
x = contourPoint[i].X;
y = contourPoint[i].Y;
pPoint = new PointClass();
pPoint.PutCoords(x, y);
pointCollection.AddPoint(pPoint, ref missing, ref missing);
}
IPolygon pPolygon = new PolygonClass();
//生成面
pPolygon = (IPolygon)pointCollection;
featureBuffer.Shape = pPolygon;
featureOID = featurecursor.InsertFeature(featureBuffer);
//对featurebuffer插入字段
//featureBuffer.set_Value(featureBuffer.Fields.FindField("Contour"), contour);
//停止编辑
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
//释放游标
System.Runtime.InteropServices.Marshal.ReleaseComObject(featurecursor);
//返回要素类
return(featureclass);
}
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"));
}
}
internal IFeatureClass CreateShapefile(string path, string name, esriGeometryType geometryType, ISpatialReference spatialRef, string idFieldName)
{
const string SHAPE_FIELD = "Shape";
IFeatureClass shapeFile = null;
IWorkspace workspace = null;
try
{
workspace = OpenShapeFileWorkspace(path);
IFeatureWorkspace featureWorkspace = workspace as IFeatureWorkspace;
//Delete any existing
IEnumDatasetName datasets = workspace.get_DatasetNames(esriDatasetType.esriDTFeatureClass);
datasets.Reset();
IDataset existing = null;
IDatasetName datasetName = datasets.Next();
while (datasetName != null)
{
if (string.Compare(name, datasetName.Name, true) == 0)
{
existing = (IDataset)((IName)datasetName).Open();
break;
}
datasetName = datasets.Next();
}
if (existing != null)
{
try
{
existing.Delete();
}
finally
{
UrbanDelineationExtension.ReleaseComObject(existing);
}
}
//Get elements to create a new table/feature class
IFieldsEdit fields = new FieldsClass();
IGeometryDefEdit geometryDef = new GeometryDefClass();
geometryDef.GeometryType_2 = geometryType;
geometryDef.SpatialReference_2 = spatialRef;
IFieldEdit shapeField = new FieldClass();
shapeField.Name_2 = SHAPE_FIELD;
shapeField.Type_2 = esriFieldType.esriFieldTypeGeometry;
shapeField.GeometryDef_2 = geometryDef;
fields.AddField(shapeField);
IFieldEdit eidField = new FieldClass();
eidField.Name_2 = idFieldName;
eidField.Type_2 = esriFieldType.esriFieldTypeInteger;
eidField.Length_2 = 16;
fields.AddField(eidField as IField);
//Create feature class
shapeFile = featureWorkspace.CreateFeatureClass(name, fields, null, null, esriFeatureType.esriFTSimple, SHAPE_FIELD, null);
}
finally
{
UrbanDelineationExtension.ReleaseComObject(workspace);
}
return(shapeFile);
}
public IEnumerable<double> GetEstimatedValues(IDataset dataset, IEnumerable<int> rows) {
return rows.Select(row => Constant);
}
public override IEnumerable <double> GetEstimatedValues(IDataset dataset, IEnumerable <int> rows)
{
return(rows.Select(row => Constant));
}
private void CalculateVariableMapping(ISymbolicExpressionTree tree, IDataset dataset) {
int columnIndex = 0;
int inputIndex = 0;
var usedVariables = tree.IterateNodesPrefix().OfType<VariableTreeNode>().Select(v => v.VariableName).Distinct();
foreach (var variable in dataset.VariableNames) {
columnIndex++;
if (!usedVariables.Contains(variable)) continue;
inputIndex++;
variableNameMapping[variable] = GetExcelColumnName(inputIndex);
}
}
public IEnumerable <double> GetEstimatedClassValues(IDataset dataset, IEnumerable <int> rows)
{
return(GetEstimatedValues(dataset, rows));
}
private static IEnumerable<double> GetSignals(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter, ISymbolicExpressionTree solution, IDataset dataset, IEnumerable<int> rows) {
return Model.GetSignals(interpreter.GetSymbolicExpressionTreeValues(solution, dataset, rows));
}
public IEnumerable <IEnumerable <double> > GetPrognosedValues(IDataset dataset, IEnumerable <int> rows, IEnumerable <int> horizons)
{
return(rows.Select(_ => horizons.Select(__ => Constant)));
}
protected void WriteInputSheet(ExcelWorksheet inputsWorksheet, ExcelWorksheet datasetWorksheet, IEnumerable<string> list, IDataset dataset) {
//remark the performance of EPPlus drops dramatically
//if the data is not written row wise (from left to right) due the internal indices used.
var variableNames = dataset.VariableNames.Select((v, i) => new { variable = v, index = i + 1 }).ToDictionary(v => v.variable, v => v.index);
var nameMapping = list.Select(x => x.Split('=')[0].Trim()).ToArray();
for (int row = 1; row <= dataset.Rows + 1; row++) {
for (int column = 1; column < nameMapping.Length + 1; column++) {
int variableIndex = variableNames[nameMapping[column - 1]];
inputsWorksheet.Cells[row, column].Formula = datasetWorksheet.Cells[row, variableIndex].FullAddress;
}
}
}
private byte[] ProcessEditAreas(IServerObject serverObject, string versionName)
{
try
{
// Open utility network
IDataset unDataset = _soiUtil.GetUNDataset(serverObject, versionName);
IWorkspace workspace = (IWorkspace)unDataset.Workspace;
// Get all the dirty areas in the given validation area
IBaseNetwork baseNetwork = (IBaseNetwork)unDataset;
ITable dirtyAreaTable = baseNetwork.DirtyAreaTable;
string shapeFieldName = ((IFeatureClass)dirtyAreaTable).ShapeFieldName;
int areaFieldIndex = dirtyAreaTable.FindField(shapeFieldName);
int creatorFieldIndex = dirtyAreaTable.FindField("CREATOR");
// Get UN schema version
IDatasetComponent dsComponent = (IDatasetComponent)unDataset;
IDEBaseNetwork deBaseNetwork = (IDEBaseNetwork)dsComponent.DataElement;
int unVersion = deBaseNetwork.SchemaGeneration;
// Get inserts made to dirty areas table in the current version
// For UN > V4, Errors are discarded (ERROCODE>0) to only retain true dirty areas
// Note that changes made in the last edit session must be saved for this to work
// as it is not possible to get the modifications until they have been saved.
IVersionedTable versionedTable = (IVersionedTable)dirtyAreaTable;
QueryFilter qryFilter = null;
if (unVersion >= 4)
{
qryFilter = new QueryFilter();
qryFilter.WhereClause = _errorCodeFName + "=0";
}
IDifferenceCursor diffCursor = versionedTable.Differences(dirtyAreaTable, esriDifferenceType.esriDifferenceTypeInsert, qryFilter);
// Loop through added rows to construct the modified zone extent
int editCount = 0;
int OID;
IRow diffRow;
IEnvelope editZone = null;
string creator = "";
diffCursor.Next(out OID, out diffRow);
// Return an error if no dirty areas found as it may be because the last edits were not saved
if (diffRow == null)
{
JSONObject responseJSON = new JSONObject();
responseJSON.AddBoolean("success", false);
JSONObject errorJSON = new JSONObject();
errorJSON.AddLong("extendedCode", (int)fdoError.FDO_E_DIRTY_AREA_BUILD_EXTENT_DO_NOT_INTERSECT);
errorJSON.AddString("message", "A dirty area is not present within the validate network topology input extent. A validate network topology process did not occur.");
JSONArray detailsJSON = new JSONArray();
detailsJSON.AddString("Make sure to save edits before validating.");
errorJSON.AddJSONArray("details", detailsJSON);
responseJSON.AddJSONObject("error", errorJSON);
return(Encoding.UTF8.GetBytes(responseJSON.ToJSONString(null)));
}
while (diffRow != null)
{
editCount += 1;
creator = diffRow.Value[creatorFieldIndex].ToString();
IGeometry rowShape = (IGeometry)diffRow.Value[areaFieldIndex];
IEnvelope rowArea = rowShape.Envelope;
if (editZone != null)
{
editZone.Union(rowArea);
}
else
{
editZone = rowArea.Envelope;
}
diffCursor.Next(out OID, out diffRow);
}
diffCursor = null;
versionedTable = null;
workspace = null;
// Add new or modify existing edit zone
if (editZone != null)
{
AddEditArea(serverObject, creator, versionName, editCount, editZone);
}
}
catch (Exception e)
{
_serverLog.LogMessage(ServerLogger.msgType.infoStandard, _soiName + ".AddEditArea()",
200, "Error while adding edit are: " + e.ToString());
}
return(null);
}
