/// <summary>
/// Encapsulates the <paramref name="operation" /> in the necessary start and stop operation constructs.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="menuText">The menu text.</param>
/// <param name="workspace">The workspace you wish to edit and this workspace must be represented in the focus map.</param>
/// <param name="operation">The delegate that performs the operation.</param>
/// <param name="error">The error handling action that occurred during commit when true is returned the error has been
/// handled.</param>
/// <returns>
/// Returns a <see cref="bool" /> representing <c>true</c> when the operation completes.
/// </returns>
/// <exception cref="System.ArgumentOutOfRangeException">source;An edit operation is already started.</exception>
public static bool PerformOperation(this IEditor source, string menuText, IWorkspace workspace, Func <bool> operation, Func <COMException, bool> error)
{
if (source == null || source.Map == null)
{
return(false);
}
source.StartEditing(workspace);
source.StartOperation();
source.Map.DelayDrawing(true);
bool saveEdits = false;
bool editOperation = true;
try
{
saveEdits = operation();
}
catch (Exception)
{
source.AbortOperation();
editOperation = false;
throw;
}
finally
{
if (editOperation)
{
if (saveEdits)
{
source.StopOperation(menuText);
}
else
{
source.AbortOperation();
}
}
try
{
source.StopEditing(saveEdits);
}
catch (COMException com)
{
if (!error(com))
{
throw;
}
source.StopEditing(saveEdits);
}
finally
{
source.Map.DelayDrawing(false);
}
}
return(saveEdits);
}
private void AbortEdits(bool bUseNonVersionedDelete, IEditor pEd, IWorkspace pWS)
{
clsFabricUtils FabricUTILS = new clsFabricUtils();
if (bUseNonVersionedDelete)
{
FabricUTILS.AbortEditing(pWS);
}
else
{
if (pEd != null)
{
if (pEd.EditState == esriEditState.esriStateEditing)
{
pEd.AbortOperation();
}
}
}
}
private static bool CreateSingle(ref IApplication app, ref IEditor editor, IFeature pointFeature, IFeatureLayer matchLineFLayer,
IFeatureLayer targetLineFLayer, IEditTemplate targetLineEditTemplate,
List<pointAlongSettings> pointAlongLayers,
bool startAtMain, bool deleteExistingLines, FromToField[] fromToPairs, double doglegDistance,
bool DistAsPercent, double tolerenceForDelete, bool store, bool SearchOnLayer, int searchDistance, double angle, bool checkSelection)
{
IFeature lineFeature = null;
IPoint thisPoint = null;
IPoint turnPoint = null;
IPoint toPoint = null;
ICurve mainCurve = null;
IPolyline polyline = null;
IFeature pFeat = null;
try
{
// Get closest main to point1
thisPoint = (IPoint)pointFeature.ShapeCopy;
lineFeature = Globals.GetClosestFeature(thisPoint, matchLineFLayer, Convert.ToDouble(searchDistance), SearchOnLayer, checkSelection);
// (_app.Document as IMxDocument).FocusMap.ClearSelection();
if (lineFeature != null)
{
//Delete any existing lateral lines at this location
if (deleteExistingLines)
{
DeleteExistingFeatures(pointFeature, targetLineFLayer, pointAlongLayers, tolerenceForDelete);
}
//Determine To and Turn Points
mainCurve = lineFeature.ShapeCopy as ICurve;
CreateToAndTurnPoints(mainCurve, thisPoint, out toPoint, out turnPoint, doglegDistance, DistAsPercent);
//Create the new line
polyline = Globals.CreatePolylineFromPointsNewTurn(thisPoint, turnPoint, toPoint, ref matchLineFLayer, ref lineFeature, SearchOnLayer, angle, editor.Map.SpatialReference);
//If requested, store pipe id in the point
StorePipeInfoPointFeature(lineFeature, pointFeature, fromToPairs, store);
if (polyline.Length > 0)
{
if (startAtMain)
polyline.ReverseOrientation();
if (targetLineEditTemplate != null)
{
pFeat = Globals.CreateFeature(polyline as IGeometry, targetLineEditTemplate, editor, app, false, false, true);
}
else
{
pFeat = Globals.CreateFeature(polyline as IGeometry, targetLineFLayer, editor, app, false, false, true);
}
if (pFeat == null)
{
editor.AbortOperation();
return false;
}
//Globals.SetFlowDirection(pFeat, targetLineFLayer);
try
{
if (pFeat != null)
{
Globals.ValidateFeature(pFeat);
pFeat.Store();
}
//if (pFeat is INetworkFeature)
//{
// INetworkFeature pNF = (INetworkFeature)pFeat;
// pNF.Connect();
//}
}
catch (Exception ex)
{
// MessageBox.Show("The Feature could not be stored, this is typically because the layer has Z and the geometric network was not created to honors, you need to drop the network and recreate it with Z's enabled\n" + ex.Message);
}
//Old Way
//IFeature pFeat = CreateLineFeature(targetLineFLayer, newPolyLine, targetLineValue, targetLineFieldName, targetLineSubtype);
//Optionally, create new point along line
// int idx = 0;
if (pointAlongLayers != null)
{
foreach (pointAlongSettings pPointAlongLayer in pointAlongLayers)
{
if (pPointAlongLayer.PolygonIntersectLayer != null)
Globals.AddPointAlongLineWithIntersect(ref app, ref editor, polyline as ICurve, pPointAlongLayer.PointAlongLayer, pPointAlongLayer.PointAlongDistance, pPointAlongLayer.DistanceIsPercent, pPointAlongLayer.PointAlongEditTemplate, pPointAlongLayer.PolygonIntersectLayer, pPointAlongLayer.PolygonIntersectSide);
else
Globals.AddPointAlongLine(ref app, ref editor, polyline as ICurve, pPointAlongLayer.PointAlongLayer, pPointAlongLayer.PointAlongDistance, pPointAlongLayer.DistanceIsPercent, pPointAlongLayer.PointAlongEditTemplate);
// idx++;
}
}
//Globals.SetFlowDirection(pFeat, targetLineFLayer,((IMxDocument)app.Document).FocusMap);
//try
//{
// if (pFeat != null)
// {
// // Globals.ValidateFeature(pFeat);
// pFeat.Store();
// }
// //if (pFeat is INetworkFeature)
// //{
// // INetworkFeature pNF = (INetworkFeature)pFeat;
// // pNF.Connect();
// //}
//}
//catch (Exception ex)
//{
// // MessageBox.Show("The Feature could not be stored, this is typically because the layer has Z and the geometric network was not created to honors, you need to drop the network and recreate it with Z's enabled\n" + ex.Message);
//}
return true;
//AddPointAlongLine(newPolyLine as ICurve, targetPointFLayer, targetPointDistance, targetPointDistanceIsPercent, targetPointSubtype, targetPointValue, targetPointFieldName);
}
else
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("ConstructionToolsError_6"));
return false;
}
}
else
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("ConstructionToolsError_5a") + matchLineFLayer.Name + A4LGSharedFunctions.Localizer.GetString("ConstructionToolsError_5b") + searchDistance + A4LGSharedFunctions.Localizer.GetString("ConstructionToolsError_5c"));
return false;
}
}
catch (Exception ex)
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("ErrorInThe") + A4LGSharedFunctions.Localizer.GetString("ConstructionToolsLbl_3") + "\n" + ex.Message, ex.Source);
return false;
}
finally
{
lineFeature = null;
thisPoint = null;
turnPoint = null;
toPoint = null;
mainCurve = null;
polyline = null;
pFeat = null;
}
}
protected override void OnClick()
{
#region Prepare for editing
IMouseCursor pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
UID pUID = new UIDClass();
pUID.Value = "{114D685F-99B7-4B63-B09F-6D1A41A4DDC1}";
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)ArcMap.Application.FindExtensionByCLSID(pUID);
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByCLSID(pUID);
//check if there is a Manual Mode "modify" job active ===========
ICadastralPacketManager pCadPacMan = (ICadastralPacketManager)pCadExtMan;
if (pCadPacMan.PacketOpen)
{
MessageBox.Show("This command cannot be used when there is an open job.\r\nPlease finish or discard the open job, and try again.",
"Delete Selected Parcels");
return;
}
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
IActiveView pActiveView = ArcMap.Document.ActiveView;
IMap pMap = pActiveView.FocusMap;
ICadastralFabric pCadFabric = null;
clsFabricUtils FabricUTILS = new clsFabricUtils();
IProgressDialog2 pProgressorDialog = null;
//if we're in an edit session then grab the target fabric
if (pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
else
{
MessageBox.Show("Please start editing and try again.");
return;
}
if (pCadFabric == null)
{//find the first fabric in the map
if (!FabricUTILS.GetFabricFromMap(pMap, out pCadFabric))
{
MessageBox.Show
("No Parcel Fabric found in the map.\r\nPlease add a single fabric to the map, and try again.");
return;
}
}
IArray CFParcelLayers = new ArrayClass();
if (!(FabricUTILS.GetFabricSubLayersFromFabric(pMap, pCadFabric, out CFPointLayer, out CFLineLayer,
out CFParcelLayers, out CFControlLayer, out CFLinePointLayer)))
{
return; //no fabric sublayers available for the targeted fabric
}
//bool bIsFileBasedGDB = false; bool bIsUnVersioned = false; bool bUseNonVersionedDelete = false;
//ICadastralFabricLayer pCFLayer = null;
IWorkspace pWS = null;
ITable pParcelsTable = null;
ITable pLinesTable = null;
ITable pLinePtsTable = null;
ITable pPointsTable = null;
pParcelsTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTParcels);
pLinesTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTLines);
pLinePtsTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTLinePoints);
pPointsTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTPoints);
#endregion
dlgChangeParcelHistory pChangeHistoryDialog = new dlgChangeParcelHistory();
// ******** Display the dialog *********
DialogResult pDialogResult = pChangeHistoryDialog.ShowDialog();
if (pDialogResult != DialogResult.OK)
{
return;
}
//************************
#region Get Selection
//Get the selection of parcels
IFeatureLayer pFL = (IFeatureLayer)CFParcelLayers.get_Element(0);
IDataset pDS = (IDataset)pFL.FeatureClass;
pWS = pDS.Workspace;
ICadastralSelection pCadaSel = (ICadastralSelection)pCadEd;
IEnumGSParcels pEnumGSParcels = pCadaSel.SelectedParcels;// need to get the parcels before trying to get the parcel count: BUG workaround
IFeatureSelection pFeatSel = (IFeatureSelection)pFL;
ISelectionSet2 pSelSet = (ISelectionSet2)pFeatSel.SelectionSet;
ICadastralFabricSchemaEdit2 pSchemaEd = null;
try
{
int iParcelCount = pCadaSel.SelectedParcelCount;
bool m_bShowProgressor = (iParcelCount > 10);
if (m_bShowProgressor)
{
m_pProgressorDialogFact = new ProgressDialogFactoryClass();
m_pTrackCancel = new CancelTrackerClass();
m_pStepProgressor = m_pProgressorDialogFact.Create(m_pTrackCancel, ArcMap.Application.hWnd);
pProgressorDialog = (IProgressDialog2)m_pStepProgressor;
m_pStepProgressor.MinRange = 1;
m_pStepProgressor.MaxRange = iParcelCount * 14; //(estimate 7 lines per parcel, 4 pts per parcel)
m_pStepProgressor.StepValue = 1;
pProgressorDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressSpiral;
}
if (m_bShowProgressor)
{
pProgressorDialog.ShowDialog();
m_pStepProgressor.Message = "Initializing...";
}
#endregion
#region Get Parcel History Fields
//Get the parcel table history fields
//SystemStart, SystemEnd, LegalStart, LegalEnd, Historic
int iParcSysStartDate = pParcelsTable.FindField("systemstartdate");
int iParcSysEndDate = pParcelsTable.FindField("systemenddate");
int iParcLegalStartDate = pParcelsTable.FindField("legalstartdate");
int iParcLegalEndDate = pParcelsTable.FindField("legalenddate");
int iParcHistorical = pParcelsTable.FindField("historical");
//Add the OIDs of all the selected parcels into a new feature IDSet
//Need a Lookup for the History information
Dictionary <int, string> ParcelToHistory_DICT = new Dictionary <int, string>();
List <string> sOIDList = new List <string>();
sOIDList.Add("");
int tokenLimit = 995;
bool bCont = true;
int j = 0;
int iCounter = 0;
m_pFIDSetParcels = new FIDSetClass();
pEnumGSParcels.Reset();
IGSParcel pGSParcel = pEnumGSParcels.Next();
while (pGSParcel != null)
{
//Check if the cancel button was pressed. If so, stop process
if (m_bShowProgressor)
{
bCont = m_pTrackCancel.Continue();
if (!bCont)
{
break;
}
}
m_pFIDSetParcels.Add(pGSParcel.DatabaseId);
if (iCounter <= tokenLimit)
{
if (sOIDList[j].Trim() == "")
{
sOIDList[j] = Convert.ToString(pGSParcel.DatabaseId);
}
else
{
sOIDList[j] = sOIDList[j] + "," + Convert.ToString(pGSParcel.DatabaseId);
}
iCounter++;
}
else
{//maximum tokens reached
iCounter = 0;
//set up the next OIDList
j++;
sOIDList.Add("");
sOIDList[j] = Convert.ToString(pGSParcel.DatabaseId);
}
//add to the lookup
IGSAttributes pGSParcelAttributes = (IGSAttributes)pGSParcel;
object pObj = pGSParcelAttributes.GetProperty("systemstartdate");
string sSystemStartParcel = "";
if (pObj != null)
{
sSystemStartParcel = pObj.ToString();
}
pObj = pGSParcelAttributes.GetProperty("systemenddate");
string sSystemEndParcel = "";
if (pObj != null)
{
sSystemEndParcel = pObj.ToString();
}
string sLegalStartParcel = pGSParcel.LegalStartDate.ToString();
string sLegalEndParcel = pGSParcel.LegalEndDate.ToString();
string sHistorical = pGSParcel.Historical.ToString();
ParcelToHistory_DICT.Add(pGSParcel.DatabaseId, sSystemStartParcel + "," +
sSystemEndParcel + "," + sLegalStartParcel + "," + sLegalEndParcel + "," +
sHistorical);
Marshal.ReleaseComObject(pGSParcel); //garbage collection
pGSParcel = pEnumGSParcels.Next();
if (m_bShowProgressor)
{
if (m_pStepProgressor.Position < m_pStepProgressor.MaxRange)
{
m_pStepProgressor.Step();
}
}
}
Marshal.ReleaseComObject(pEnumGSParcels); //garbage collection
#endregion
#region Confirm Edit Locks
bool bIsFileBasedGDB = false;
bool bIsUnVersioned = false;
bool bUseNonVersioned = false;
if (!FabricUTILS.SetupEditEnvironment(pWS, pCadFabric, pEd, out bIsFileBasedGDB,
out bIsUnVersioned, out bUseNonVersioned))
{
return;
}
//if we're in an enterprise then test for edit locks
string sTime = "";
if (!bIsUnVersioned && !bIsFileBasedGDB)
{
//see if parcel locks can be obtained on the selected parcels. First create a job.
DateTime localNow = DateTime.Now;
sTime = Convert.ToString(localNow);
ICadastralJob pJob = new CadastralJobClass();
pJob.Name = sTime;
pJob.Owner = System.Windows.Forms.SystemInformation.UserName;
pJob.Description = "Delete selected parcels";
try
{
Int32 jobId = pCadFabric.CreateJob(pJob);
}
catch (COMException ex)
{
if (ex.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_ALREADY_EXISTS)
{
MessageBox.Show("Job named: '" + pJob.Name + "', already exists");
}
else
{
MessageBox.Show(ex.Message);
}
m_pStepProgressor = null;
if (!(pProgressorDialog == null))
{
pProgressorDialog.HideDialog();
}
pProgressorDialog = null;
Marshal.ReleaseComObject(pJob);
if (bUseNonVersioned)
{
pCadEd.CadastralFabricLayer = null;
}
return;
}
Marshal.ReleaseComObject(pJob);
}
ICadastralFabricLocks pFabLocks = (ICadastralFabricLocks)pCadFabric;
if (!bIsUnVersioned && !bIsFileBasedGDB)
{
pFabLocks.LockingJob = sTime;
ILongArray pLocksInConflict = null;
ILongArray pSoftLcksInConflict = null;
ILongArray pParcelsToLock = new LongArrayClass();
FabricUTILS.FIDsetToLongArray(m_pFIDSetParcels, ref pParcelsToLock, m_pStepProgressor);
if (m_bShowProgressor && !bIsFileBasedGDB)
{
m_pStepProgressor.Message = "Testing for edit locks on parcels...";
}
try
{
pFabLocks.AcquireLocks(pParcelsToLock, true, ref pLocksInConflict, ref pSoftLcksInConflict);
}
catch (COMException pCOMEx)
{
if (pCOMEx.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_LOCK_ALREADY_EXISTS ||
pCOMEx.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_CURRENTLY_EDITED)
{
MessageBox.Show("Edit Locks could not be acquired on all selected parcels.");
// since the operation is being aborted, release any locks that were acquired
pFabLocks.UndoLastAcquiredLocks();
}
else
{
MessageBox.Show(pCOMEx.Message + Environment.NewLine + Convert.ToString(pCOMEx.ErrorCode));
}
if (bUseNonVersioned)
{
pCadEd.CadastralFabricLayer = null;
}
return;
}
Marshal.ReleaseComObject(pSoftLcksInConflict);
Marshal.ReleaseComObject(pParcelsToLock);
Marshal.ReleaseComObject(pLocksInConflict);
}
#endregion
string sParcelSysEndDate = pParcelsTable.Fields.get_Field(iParcSysEndDate).Name;
string sParcelLegalStartDate = pParcelsTable.Fields.get_Field(iParcLegalStartDate).Name;
string sParcelLegalEndDate = pParcelsTable.Fields.get_Field(iParcLegalEndDate).Name;
string sParcelHistoric = pParcelsTable.Fields.get_Field(iParcHistorical).Name;
if (m_bShowProgressor)
{
pProgressorDialog.ShowDialog();
m_pStepProgressor.Message = "Updating parcel history...";
}
pEd.StartOperation();
#region The Edit
//make change to parcels
bool bSuccess = false;
ICursor pCurs = null;
IQueryFilter pQuFilter = new QueryFilterClass();
pQuFilter.SubFields = pParcelsTable.OIDFieldName + "," + sParcelLegalEndDate + "," + sParcelLegalStartDate
+ "," + sParcelSysEndDate + "," + sParcelHistoric;
bool bSystemEndDate_Clear = pChangeHistoryDialog.chkSystemEndDate.Checked &&
pChangeHistoryDialog.optClearSEDate.Checked;
bool bLegalStDate_Clear = pChangeHistoryDialog.chkLegalStartDate.Checked &&
pChangeHistoryDialog.optClearLSDate.Checked;
bool bLegalEndDate_Clear = pChangeHistoryDialog.chkLegalEndDate.Checked &&
pChangeHistoryDialog.optClearLEDate.Checked;
bool bSystemEndDate_Set = pChangeHistoryDialog.chkSystemEndDate.Checked &&
pChangeHistoryDialog.optChooseSEDate.Checked;
bool bLegalStDate_Set = pChangeHistoryDialog.chkLegalStartDate.Checked &&
pChangeHistoryDialog.optChooseLSDate.Checked;
bool bLegalEndDate_Set = pChangeHistoryDialog.chkLegalEndDate.Checked &&
pChangeHistoryDialog.optChooseLEDate.Checked;
List <bool> bHistory = new List <bool>();
bHistory.Add(bSystemEndDate_Clear);
bHistory.Add(bLegalStDate_Clear);
bHistory.Add(bLegalEndDate_Clear);
bHistory.Add(bSystemEndDate_Set);
bHistory.Add(bLegalStDate_Set);
bHistory.Add(bLegalEndDate_Set);
List <string> sDates = new List <string>();
sDates.Add(pChangeHistoryDialog.dtSEDatePicker.Text);
sDates.Add(pChangeHistoryDialog.dtLSDatePicker.Text);
sDates.Add(pChangeHistoryDialog.dtLEDatePicker.Text);
pSchemaEd = (ICadastralFabricSchemaEdit2)pCadFabric;
pSchemaEd.ReleaseReadOnlyFields(pLinesTable, esriCadastralFabricTable.esriCFTLines); //release safety-catch
pSchemaEd.ReleaseReadOnlyFields(pParcelsTable, esriCadastralFabricTable.esriCFTParcels); //release safety-catch
pSchemaEd.ReleaseReadOnlyFields(pPointsTable, esriCadastralFabricTable.esriCFTPoints); //release safety-catch
foreach (string sInClause in sOIDList)
{
if (sInClause.Trim() == "")
{
continue;
}
pQuFilter.WhereClause = pParcelsTable.OIDFieldName + " IN (" + sInClause + ")";
pCurs = pParcelsTable.Update(pQuFilter, false);
bSuccess = FabricUTILS.ChangeDatesOnTableMulti(pCurs, bHistory, sDates, bUseNonVersioned,
ParcelToHistory_DICT, m_pStepProgressor, m_pTrackCancel);
if (!bSuccess)
{
if (!bIsUnVersioned)
{
pFabLocks.UndoLastAcquiredLocks();
}
if (bUseNonVersioned)
{
FabricUTILS.AbortEditing(pWS);
}
else
{
pEd.AbortOperation();
}
//clear selection, to make sure the parcel explorer is updated and refreshed properly
return;
}
}
//make change to points and lines
if (!FabricUTILS.UpdateHistoryOnLines(pLinesTable, pPointsTable, iParcelCount,
pCadFabric, sOIDList, ParcelToHistory_DICT, m_pStepProgressor, m_pTrackCancel))
{
if (!bIsUnVersioned)
{
pFabLocks.UndoLastAcquiredLocks();
}
if (bUseNonVersioned)
{
FabricUTILS.AbortEditing(pWS);
}
else
{
pEd.AbortOperation();
}
}
else
{
pEd.StopOperation("Change Parcel History");
}
#endregion
//now refresh the map layers
RefreshMap(pActiveView, CFParcelLayers, CFPointLayer, CFLineLayer, CFControlLayer, CFLinePointLayer);
}
catch (Exception ex)
{
pEd.AbortOperation();
MessageBox.Show("Error:" + ex.Message);
}
finally
{
if (!(pProgressorDialog == null))
{
pProgressorDialog.HideDialog();
}
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTPoints); //set safety back on
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTLines); //set safety back on
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTParcels); //set safety back on
}
}
protected override void OnClick()
{
//go get a traverse file
// Display .Net dialog for File selection.
OpenFileDialog openFileDialog = new OpenFileDialog();
// Set File Filter
openFileDialog.Filter = "Cadastral XML file (*.xml)|*.xml";
// Enable multi-select
openFileDialog.Multiselect = true;
// Don't need to Show Help
openFileDialog.ShowHelp = false;
// Set Dialog Title
openFileDialog.Title = "Append Cadastral XML files";
openFileDialog.FilterIndex = 2;
// Display Open File Dialog
if (openFileDialog.ShowDialog() != DialogResult.OK)
{
openFileDialog = null;
return;
}
//Get the cadastral editor
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByName("esriCadastralUI.CadastralEditorExtension");
ICadastralFabric pCadFabric = pCadEd.CadastralFabric;
IEditor pEd = ArcMap.Editor;
ITrackCancel pTrkCan = new CancelTracker();
// Create and display the Progress Dialog
IProgressDialogFactory pProDlgFact = new ProgressDialogFactory();
IProgressDialog2 pProDlg = pProDlgFact.Create(pTrkCan, 0) as IProgressDialog2;
//Set the properties of the Progress Dialog
pProDlg.CancelEnabled = true;
pProDlg.Description = " ";
pProDlg.Title = "Append";
pProDlg.Animation = esriProgressAnimationTypes.esriProgressGlobe;
string sCopiedCadastralXMLFile = "";
try
{
ICadastralJob CadaJob;
bool bJobExists = false; //used to trap for the special error message condition of existing job
pEd.StartOperation();
#region workaround for setting Projection
ICadastralJob CadaJobTemp;
bJobExists = false;
if (!CreateCadastralJob(pCadFabric, "TEMPJOB", out CadaJobTemp, true, ref bJobExists))
{
if (!bJobExists) // if the create job failed for some other reason than it already exists, then bail out.
{
MessageBox.Show("Job could not be created.");
return;
}
}
//do an extract to set the spatial reference: bug workaround
((ICadastralFabric3)pCadFabric).ExtractCadastralPacket(CadaJobTemp.Name, ArcMap.Document.ActiveView.FocusMap.SpatialReference as IProjectedCoordinateSystem, null, true);
#endregion
//make a temporary file for the edited cadastral XML that is used for the fabric update
string sTempPath = System.IO.Path.GetTempPath();
sCopiedCadastralXMLFile = System.IO.Path.Combine(sTempPath, "LastUpdatedCadastralXMLAppendedFromBatch.xml");
int iFileCount = 0;
int iTotalFiles = openFileDialog.FileNames.GetLength(0);
List <string> lstPlans = new List <string>();
#region get all plan names for all files
foreach (String CadastralXMLPath in openFileDialog.FileNames)
{
TextReader tr = null;
try
{
tr = new StreamReader(CadastralXMLPath);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
// string[] sFileLine = new string[0]; //define as dynamic array
string sLine = "";
int iCount = 0;
bool bInPlanData = false;
bool bInParcel = false;
//fill the array with the lines from the file
while (sLine != null)
{
sLine = tr.ReadLine();
try
{
if (sLine.Trim().Length >= 1) //test for empty lines
{
if (!bInParcel && !bInPlanData)
{
bInPlanData = sLine.Contains("<plan>");
}
if (bInPlanData && sLine.Contains("<name>") && sLine.Contains("</name>"))
{
string sPlanName = sLine.Replace("<name>", "").Replace("</name>", "").Replace("\t", "").Trim();
if (!lstPlans.Contains(sPlanName))
{
lstPlans.Add(sPlanName);
}
bInPlanData = false;
}
}
iCount++;
}
catch { }
}
tr.Close(); //close the file and release resources
}
string sInClause = "";
foreach (string sPlan in lstPlans)
{
sInClause += "'" + sPlan + "'" + ",";
}
sInClause = sInClause.Remove(sInClause.LastIndexOf(","), 1);
ITable pPlansTable = pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTPlans);
int iNameFld = pPlansTable.FindField("Name");
IQueryFilter pQuFilter = new QueryFilterClass();
pQuFilter.WhereClause = "NAME IN (" + sInClause + ")";
ICursor pCur = pPlansTable.Search(pQuFilter, false);
List <string> lstPlanReplace = new List <string>();
IRow pPlan = pCur.NextRow();
while (pPlan != null)
{
lstPlanReplace.Add("<name>" + (string)pPlan.Value[iNameFld] + "</name>\n\t\t<oID>" + pPlan.OID.ToString() + "</oID>");
Marshal.ReleaseComObject(pPlan);
pPlan = pCur.NextRow();
}
Marshal.ReleaseComObject(pCur);
#endregion
foreach (String CadastralXMLPath in openFileDialog.FileNames)
{
if (!pTrkCan.Continue())
{
pEd.AbortOperation();
return;
}
//rename ALL oID tags so that they're ignored. This indicates that these are to be treated as NEW parcels coming in.
ReplaceInFile(CadastralXMLPath, sCopiedCadastralXMLFile, "oID>", "old_xxX>");
foreach (string sPlanTag in lstPlanReplace)
{
string sFirstPart = sPlanTag.Substring(0, sPlanTag.IndexOf("\n"));
ReplaceInFile(sCopiedCadastralXMLFile, sCopiedCadastralXMLFile, sFirstPart, sPlanTag);
}
//TEST ONLY
//ReplaceInFile(CadastralXMLPath, sCopiedCadastralXMLFile, "oID>", "oID>");
//IF using PostCadastralPacket the points are not all merged. If using PostCadastralPacket, then a merge-point workaround would be to analyze coordinates
//of incoming file and if any are identical to existing fabric coordinates, then make the oID tag match
//the oID of the existing point in the target fabric. This will trigger point merging of identical points when using PostCadastralPacket.
//code below uses InsertCadastralPacket and so point merging is handled.
IXMLStream pStream = new XMLStream();
pStream.LoadFromFile(sCopiedCadastralXMLFile);
IFIDSet pFIDSet = null;//new FIDSet();
DateTime localNow = DateTime.Now;
string sJobName = Convert.ToString(localNow) + "_" + (iFileCount++).ToString();
// note the create option is to NOT write job to fabric and is in-memory only initially, and then the InsertCadastralPacket will create and store the job in the fabric
// IF using PostCadastralPacket, then this option should be set to true, so that the job already exists in the fabric.
// Also, when using PostCadastralPacket, you can continue to use the same Target job, and a new one is not needed for each iteration.
// With InsertCadastralPacket a job is created for each call when new parcels are being created.
if (!CreateCadastralJob(pCadFabric, sJobName, out CadaJob, false, ref bJobExists))
{
pEd.AbortOperation();
return;
}
pProDlg.Description = "File: " + System.IO.Path.GetFileName(CadastralXMLPath) + " (" + iFileCount.ToString() + " of " + iTotalFiles.ToString() + ")";
//(pCadFabric as ICadastralFabric3).PostCadastralPacket(pStream, pTrkCan, esriCadastralPacketSetting.esriCadastralPacketNoSetting, ref pFIDSet);
(pCadFabric as ICadastralFabric3).InsertCadastralPacket(CadaJob, pStream, pTrkCan, esriCadastralPacketSetting.esriCadastralPacketNoSetting, ref pFIDSet);
//int setCnt = pFIDSet.Count();
}
RefreshFabricLayers(ArcMap.Document.ActiveView.FocusMap, pCadFabric);
pEd.StopOperation("Append " + iFileCount.ToString() + " cadastral XML files");
}
catch (Exception ex)
{
pEd.AbortOperation();
COMException c_Ex;
int errorCode = 0;
if (ex is COMException)
{
c_Ex = (COMException)ex;
errorCode = c_Ex.ErrorCode;
}
if (errorCodeDict.ContainsKey(errorCode))
{
MessageBox.Show(errorCodeDict[errorCode], "Append files");
}
else
{
MessageBox.Show("Error: " + ex.Message + Environment.NewLine + ex.HResult.ToString(), "Append files");
}
}
finally
{
if (sCopiedCadastralXMLFile != string.Empty)
{
File.Delete(sCopiedCadastralXMLFile);
}
if (pProDlg != null)
{
pProDlg.HideDialog();
}
}
}
void IEditTask.OnFinishSketch()
{
if (m_editSketch == null)
{
return;
}
bool HasCutPolygons = false;
//Change the cursor to be hourglass shape.
System.Windows.Forms.Cursor.Current = Cursors.WaitCursor;
try
{
//Get the geometry that performs the cut from the edit sketch.
IGeometry cutGeometry = m_editSketch.Geometry;
//The sketch geometry is simplified to deal with a multi-part sketch as well
//as the case where the sketch loops back over itself.
ITopologicalOperator2 topoOperator = cutGeometry as ITopologicalOperator2;
topoOperator.IsKnownSimple_2 = false;
topoOperator.Simplify();
//Get ready to invalidate the features.
IInvalidArea refreshArea = new InvalidAreaClass();
refreshArea.Add(cutGeometry.Envelope);
//Create the spatial filter to search for features in the target feature class.
//The spatial relationship we care about is whether the interior of the line
//intesects the interior of the polygon.
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = m_editSketch.Geometry;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
//Find the polygon features that cross the sketch.
IFeatureClass featureClass = m_editLayer.CurrentLayer.FeatureClass;
IFeatureCursor featureCursor = featureClass.Search(spatialFilter, false);
//Only do work if there are features that intersect the edit sketch.
IFeature origFeature = featureCursor.NextFeature();
if (origFeature != null)
{
//Check the first feature to see if it is ZAware and if it needs to make the
//cut geometry ZAware.
IZAware zAware = origFeature.Shape as IZAware;
if (zAware.ZAware)
{
zAware = cutGeometry as IZAware;
zAware.ZAware = true;
}
//The result selection set will be the new features created. This means
//we need to add the currently selected features to the refresh area so
//they are correctly invalidated.
if (m_editor.SelectionCount > 0)
{
IEnumFeature selectedFeatures = m_editor.EditSelection;
selectedFeatures.Reset();
IFeature selectedFeature = selectedFeatures.Next();
while (selectedFeature != null)
{
refreshArea.Add(selectedFeature);
selectedFeature = selectedFeatures.Next();
}
}
//Initialize the selection set for the new features.
IFeatureSelection featureSelect = m_editLayer.CurrentLayer as IFeatureSelection;
featureSelect.Clear();
//Cache the new features created.
ISelectionSet selectionSet = featureSelect.SelectionSet;
//Start an edit operation so we can have undo/redo.
m_editor.StartOperation();
//Cycle through the features, cutting with the sketch.
while (origFeature != null)
{
try
{
//Add the feature to the invalidate object.
refreshArea.Add(origFeature);
//Split the feature. Use the IFeatureEdit::Split method which ensures
//the attributes are correctly dealt with.
IFeatureEdit featureEdit = origFeature as IFeatureEdit;
//Set to hold the new features that are created by the Split.
ISet newFeaturesSet = featureEdit.Split(cutGeometry);
//New features have been created, loop through the set and flash
//each feature and get it's OID for the final selection set.
if (newFeaturesSet != null)
{
newFeaturesSet.Reset();
//A list to hold the selected features' OIDs.
List <int> iOIDList = new List <int>();
for (int featureCount = 0; featureCount < newFeaturesSet.Count; featureCount++)
{
HasCutPolygons = true;
//Flash the new features.
IFeature newFeature = newFeaturesSet.Next() as IFeature;
FlashGeometry(newFeature.Shape, m_editor.Display);
//Add the feature to the new selection set
iOIDList.Add(newFeature.OID);
}
int[] iOIDArray = iOIDList.ToArray();
selectionSet.AddList(newFeaturesSet.Count, ref iOIDArray[0]);
}
}
catch (COMException)
{
}
finally
{
//Continue to work on the next feature if it fails to split the current one.
origFeature = featureCursor.NextFeature();
}
}
//If any polygons were cut, invalidate the display and stop the edit operation.
if (HasCutPolygons)
{
//Clear the map's selection.
m_mxDoc.FocusMap.ClearSelection();
//Select the new features.
featureSelect.SelectionSet = selectionSet;
//Refresh the display.
refreshArea.Display = m_editor.Display;
refreshArea.Invalidate((short)esriScreenCache.esriAllScreenCaches);
//Complete the edit operation.
m_editor.StopOperation("Cut Polygons Without Selection");
//As we changed the selection set, the map has no idea we did this.
//Fire the event to inform others the selection has changed.
featureSelect.SelectionChanged();
}
else
{
m_editor.AbortOperation();
}
}
}
catch (Exception e)
{
MessageBox.Show("Unable to perform the cut task.\n" + e.ToString());
//In the event of an error, abort the operation.
m_editor.AbortOperation();
}
finally
{
//Change the cursor shape to default.
System.Windows.Forms.Cursor.Current = Cursors.Default;
}
}
private void btnOK_Click(object sender, EventArgs e)
{
IFeature pAttributeFeature = default(IFeature);
ISubtypes pSubtypes = default(ISubtypes);
ArrayList colAttributes = null;
IFeature pCurFeature = default(IFeature);
IFeature pNewFeature = default(IFeature);
IGeometry pCurGeom = default(IGeometry);
IGeometry pTmpGeom = default(IGeometry);
ITopologicalOperator5 pTopoOperator = default(ITopologicalOperator5);
IRowSubtypes pOutRSType = default(IRowSubtypes);
IFields pFlds = default(IFields);
IField pFld = default(IField);
IDomain pDomain = default(IDomain);
IGeometryCollection pGeomColl = default(IGeometryCollection);
IInvalidArea pRefresh = null;
IComplexEdgeFeature pCEF = null;
IMap pMap = null;
try
{
long lGTotalVal = 0;
int lSubTypeCode = 0;
string strOID = null;
int intOID = -1;
int i, j;
//Screen.MousePointer = vbHourglass
//The Next button doesn't get enabled until at least 1 FC is selected, but just in case...
if (lstMergeFeatures.Items.Count == 0)
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("SlctOneFtr"));
return;
}
//For Next loop which iterates through the array populating colSelClasses
//This is for when I implement selecting multiple feature classes from the listbox....
for (i = 0; i <= lstMergeFeatures.Items.Count - 1; i++)
{
if (lstMergeFeatures.Items[i].Selected)
{
strOID = lstMergeFeatures.Items[i].Text;
intOID = Convert.ToInt32(strOID);
break; // TODO: might not be correct. Was : Exit For
}
}
if (strOID == null)
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("SlctMainFtr"));
return;
}
//Get the field values of the selected feature for use later
pAttributeFeature = (IFeature)m_colFeatures[strOID];
colAttributes = new ArrayList();
for (i = 0; i < pAttributeFeature.Fields.FieldCount; i++)
{
colAttributes.Add(pAttributeFeature.get_Value(i).ToString());
}
pSubtypes = (ISubtypes)m_FeatLay.FeatureClass;
if (pSubtypes.HasSubtype)
{
lSubTypeCode = (int)pAttributeFeature.get_Value(pSubtypes.SubtypeFieldIndex);
}
else
{
lSubTypeCode = 0;
}
//If the features being merged and the target layer are the same FC and if that FC has subtypes, get the subtype code of the selected feature or target layer
//If not, get the default
//pSubtypes = m_pFC;
//if pSubtypes.HasSubtype Then
// lSubTypeCode = m_lSubtype
//End If
//start edit operation
m_editor.StartOperation();
//pEnumFeature = m_pEditor.EditSelection
//pEnumFeature.Reset
//create a new feature to be the merge feature
//pNFC = m_pFC 'QI
//Create the new feature
pNewFeature = m_FeatLay.FeatureClass.CreateFeature();
//create the new geometry.
//initialize the default values for the new feature
pOutRSType = (IRowSubtypes)pNewFeature; //Set the RowSubtypes to the NewFeature
//if (lSubTypeCode <> 0 )
pOutRSType.SubtypeCode = lSubTypeCode; //If there's a subtype code, set it
//End If
pOutRSType.InitDefaultValues(); //Init the Default values for the feature
pFlds = m_FeatLay.FeatureClass.Fields;
//Loop until we've gone through all the selected features (pCurFeature)
i = 0;
IList <MergeSplitFlds> pFldsNames = new List <MergeSplitFlds>();
if (m_Config != null)
{
if (m_Config.Count > 0)
{
if (m_Config[0] != null)
{
if (m_Config[0].Fields != null)
{
foreach (A4LGSharedFunctions.Field FldNam in m_Config[0].Fields)
{
int idx = Globals.GetFieldIndex(pFlds, FldNam.Name);
if (idx > -1)
{
try
{
pFldsNames.Add(new MergeSplitFlds(FldNam.Name, idx, "", FldNam.MergeRule, FldNam.SplitRule));
}
catch { }
}
}
}
}
}
}
foreach (string ky in m_colFeatures.Keys)
{
//}
//for (i = 0; i < m_colFeatures.Count; i++)
//{
pCurFeature = (IFeature)m_colFeatures[ky];
if (pFldsNames != null)
{
foreach (MergeSplitFlds FldNam in pFldsNames)
{
string testVal = pCurFeature.get_Value(FldNam.FieldIndex).ToString();
//if (Globals.IsNumeric(testVal))
//{
// FldNam.Value = FldNam.Value + Convert.ToDouble(testVal);
//}
switch (FldNam.MergeType.ToUpper())
{
case "MAX":
if (FldNam.Value == "")
{
FldNam.Value = testVal;
}
else
{
if (Convert.ToDouble(FldNam.Value) < Convert.ToDouble(testVal))
{
FldNam.Value = testVal;
}
}
break;
case "MIN":
if (FldNam.Value == "")
{
FldNam.Value = testVal;
}
else
{
if (Convert.ToDouble(FldNam.Value) > Convert.ToDouble(testVal))
{
FldNam.Value = testVal;
}
}
break;
case "SUM":
if (FldNam.Value == "")
{
FldNam.Value = testVal;
}
else
{
FldNam.Value += Convert.ToDouble(FldNam.Value) + Convert.ToDouble(testVal);
}
break;
case "AVERAGE":
if (FldNam.Value == "")
{
FldNam.Value = testVal;
}
else
{
FldNam.Value += Convert.ToDouble(FldNam.Value) + Convert.ToDouble(testVal);
}
FldNam.AvgCount++;
break;
case "CONCAT":
if (FldNam.Value.Contains(testVal.ToString() + ConcatDelim))
{
}
else if (FldNam.Value.Contains(ConcatDelim + testVal.ToString()))
{
}
else
{
if (FldNam.Value == "")
{
FldNam.Value = testVal.ToString();
}
else
{
FldNam.Value += ConcatDelim + testVal.ToString();
}
}
break;
default:
break;
}
}
}
//get the geometry of the current feature, if it's the first feature, set it to pTmpGeom
//Otherwise, pTmpGeom is already set so Union the Geom of this feature with pTmpGeom
//And set that equal to the new pTmpGeom......
pCurGeom = pCurFeature.ShapeCopy;
if (i == 0)
{
pTmpGeom = pCurGeom;
pTopoOperator = (ESRI.ArcGIS.Geometry.ITopologicalOperator5)pTmpGeom;
pTopoOperator.IsKnownSimple_2 = false; //051710
pTopoOperator.Simplify(); // 051710
}
else
{
//Simplify the just obtained OtherPolyLine
pTopoOperator = (ESRI.ArcGIS.Geometry.ITopologicalOperator5)pCurGeom;//051710
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
//Reset the pTopoOp to pNewPolyLine in prep for the union
pTopoOperator = (ESRI.ArcGIS.Geometry.ITopologicalOperator5)pTmpGeom;
pTmpGeom = pTopoOperator.Union(pCurGeom);
//Simplify the resulting New Line
pTopoOperator = (ESRI.ArcGIS.Geometry.ITopologicalOperator5)pTmpGeom;
pTopoOperator.IsKnownSimple_2 = false;
pTopoOperator.Simplify();
//pTopoOperator = (ITopologicalOperator5)pTmpGeom;
//pTopoOperator.Simplify();
//pOutputGeometry = pTopoOperator.Union(pCurGeom);
//pTopoOperator.Simplify();
//pTmpGeom = pOutputGeometry;
//pTopoOperator.SimplifyAsFeature();
//pOutputGeometry = pTopoOperator.UnionEx(pCurGeom,true);
//pTopoOperator.SimplifyAsFeature();
//pTmpGeom = pOutputGeometry;
//pTopoOperator.Simplify();
//pOutputGeometry = pTopoOperator.Union(pCurGeom);
//pTmpGeom = pOutputGeometry;
}
//now go through each field, if it has a domain associated with it, then evaluate the merge policy...
//If not domain, then grab the value from the selected feature
for (j = 0; j < pFlds.FieldCount; j++)
{
pFld = pFlds.get_Field(j);
pDomain = pSubtypes.get_Domain(lSubTypeCode, pFld.Name);
if (pDomain != null && pFld.DefaultValue != null)
{
if (pDomain.MergePolicy == esriMergePolicyType.esriMPTSumValues)
{
//if (lCount == 1)
// pNewFeature.set_Value(j, pCurFeature.get_Value(j));
//else
if (pNewFeature.get_Value(j) != null && pCurFeature.get_Value(j) != null)
{
if (Globals.IsNumeric(pNewFeature.get_Value(j).ToString()) && Globals.IsNumeric(pCurFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (double)pNewFeature.get_Value(j) + (double)pCurFeature.get_Value(j));
}
else if (Globals.IsNumeric(pNewFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (double)pNewFeature.get_Value(j));
}
else if (Globals.IsNumeric(pCurFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (double)pCurFeature.get_Value(j));
}
}
else if (pNewFeature.get_Value(j) != null)
{
if (Globals.IsNumeric(pNewFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (double)pNewFeature.get_Value(j));
}
}
else if (pCurFeature.get_Value(j) != null)
{
if (Globals.IsNumeric(pCurFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (double)pCurFeature.get_Value(j));
}
}
else
{
}
}
else if (pDomain.MergePolicy == esriMergePolicyType.esriMPTAreaWeighted)
{
if (pNewFeature.get_Value(j) != null && pCurFeature.get_Value(j) != null)
{
if (Globals.IsNumeric(pNewFeature.get_Value(j).ToString()) && Globals.IsNumeric(pCurFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (Double)pNewFeature.get_Value(j) + ((Double)pCurFeature.get_Value(j) * (Globals.GetGeometryLength(pCurFeature) / lGTotalVal)));
}
else if (Globals.IsNumeric(pNewFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (Double)pNewFeature.get_Value(j) * (Globals.GetGeometryLength(pCurFeature) / lGTotalVal));
}
else if (Globals.IsNumeric(pCurFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (Double)pCurFeature.get_Value(j) * (Globals.GetGeometryLength(pCurFeature) / lGTotalVal));
}
}
else if (pNewFeature.get_Value(j) != null)
{
if (Globals.IsNumeric(pNewFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (Double)pNewFeature.get_Value(j) * (Globals.GetGeometryLength(pCurFeature) / lGTotalVal));
}
}
else if (pCurFeature.get_Value(j) != null)
{
if (Globals.IsNumeric(pCurFeature.get_Value(j).ToString()))
{
pNewFeature.set_Value(j, (Double)pCurFeature.get_Value(j) * (Globals.GetGeometryLength(pCurFeature) / lGTotalVal));
}
}
else
{
}
}
else if (pCurFeature.OID == pAttributeFeature.OID)
{
try
{
pNewFeature.set_Value(j, pCurFeature.get_Value(j));
}
catch
{ }
}
}
else
if (pCurFeature.OID == intOID)
{
//Set the field values from the selected feature; ignore Subtype, non-editable and Shape field
if (pFld.Editable == true && pSubtypes.SubtypeFieldIndex != j && m_FeatLay.FeatureClass.ShapeFieldName.ToUpper() != pFld.Name.ToUpper())
{
//if (colAttributes[j] != null)
//{
try
{
pNewFeature.set_Value(j, colAttributes[j]);
}
catch { }
// }
}
}
}
pCurFeature.Delete(); //delete the feature
i++;
}
//Check if the merged geometry is multi-part. If so, raise an error and abort
//Multipart geometries are not supported in the geometric network.
pGeomColl = (IGeometryCollection)pTmpGeom;
if (pGeomColl.GeometryCount > 1)
{
m_editor.AbortOperation();
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("SlctOneFtr"), A4LGSharedFunctions.Localizer.GetString("ErrorOn") + A4LGSharedFunctions.Localizer.GetString("MergeOprt_4"));
this.Close();
return;
}
pNewFeature.Shape = pTmpGeom;
pNewFeature.Store();
if (m_FeatLay.FeatureClass.FeatureType == esriFeatureType.esriFTComplexEdge)
{
pCEF = (IComplexEdgeFeature)pNewFeature;
pCEF.ConnectAtIntermediateVertices();
}
if (chkMergeElevationData.Checked)
{
if (pFldsNames != null)
{
foreach (MergeSplitFlds FldNam in pFldsNames)
{
if (FldNam.MergeType.ToUpper() == "Average".ToUpper())
{
FldNam.Value = (Convert.ToDouble(FldNam.Value) / FldNam.AvgCount).ToString();
}
try
{
pNewFeature.set_Value(FldNam.FieldIndex, FldNam.Value);
}
catch
{
}
}
}
}
//finish edit operation
m_editor.StopOperation(A4LGSharedFunctions.Localizer.GetString("MergeOprt_4"));
//refresh features
pRefresh = new InvalidArea();
pRefresh.Display = m_editor.Display;
pRefresh.Add(pNewFeature);
pRefresh.Invalidate(-2);
// 'select new feature
pMap = m_editor.Map;
pMap.ClearSelection();
pMap.SelectFeature((ILayer)m_FeatLay, pNewFeature);
this.Close();
}
catch (Exception ex)
{
if (ex.ToString().ToString().Contains("Key cannot be null"))
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("ErrorOn") + A4LGSharedFunctions.Localizer.GetString("MergeOprt_5") + "\r\n" + A4LGSharedFunctions.Localizer.GetString("MergeOprt_6"));
}
else
{
MessageBox.Show(A4LGSharedFunctions.Localizer.GetString("ErrorOn") + A4LGSharedFunctions.Localizer.GetString("MergeOprt_5") + "\r\n" + ex.ToString());
}
try
{
//finish edit operation
m_editor.StopOperation(A4LGSharedFunctions.Localizer.GetString("MergeOprt_4"));
}
catch
{ }
this.Close();
}
finally
{
pAttributeFeature = null;
pSubtypes = null;
colAttributes = null;
pCurFeature = null;
pNewFeature = null;
pCurGeom = null;
pTmpGeom = null;
pTopoOperator = null;
pOutRSType = null;
pFlds = null;
pFld = null;
pDomain = null;
pGeomColl = null;
pRefresh = null;
pCEF = null;
pMap = null;
}
}
protected override void OnClick()
{
IEditor m_pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByName("esriCadastralUI.CadastralEditorExtension");
if (m_pEd.EditState == esriEditState.esriStateNotEditing)
{
MessageBox.Show("Please start editing first, and try again.", "Start Editing", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
IArray PolygonLyrArr;
IMap pMap = m_pEd.Map;
ICadastralFabric pCadFabric = null;
//if we're in an edit session then grab the target fabric
if (m_pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
if (pCadFabric == null)
{//find the first fabric in the map
MessageBox.Show
("No Parcel Fabric found in the workspace you're editing.\r\nPlease re-start editing on a workspace with a fabric, and try again.",
"No Fabric found", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
Utilities Utils = new Utilities();
if (!Utils.GetFabricSubLayers(pMap, esriCadastralFabricTable.esriCFTParcels, out PolygonLyrArr))
{
return;
}
//check if there is a Manual Mode "modify" job active ===========
ICadastralPacketManager pCadPacMan = (ICadastralPacketManager)pCadEd;
if (pCadPacMan.PacketOpen)
{
MessageBox.Show("The Area Calculation does not work when the parcel is open.\r\nPlease close the parcel and try again.",
"Calculate Stated Area", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
IActiveView pActiveView = ArcMap.Document.ActiveView;
CalcStatedAreaDLG CalcStatedArea = new CalcStatedAreaDLG();
bool bIsFileBasedGDB = false; bool bIsUnVersioned = false; bool bUseNonVersionedEdit = false;
IWorkspace pWS = null;
ITable pParcelsTable = null;
IProgressDialog2 pProgressorDialog = null;
IMouseCursor pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
var pTool = ArcMap.Application.CurrentTool;
try
{
IFeatureLayer pFL = (IFeatureLayer)PolygonLyrArr.get_Element(0);
IDataset pDS = (IDataset)pFL.FeatureClass;
pWS = pDS.Workspace;
if (!Utils.SetupEditEnvironment(pWS, pCadFabric, m_pEd, out bIsFileBasedGDB,
out bIsUnVersioned, out bUseNonVersionedEdit))
{
return;
}
ICadastralSelection pCadaSel = (ICadastralSelection)pCadEd;
IEnumGSParcels pEnumGSParcels = pCadaSel.SelectedParcels;// need to get the parcels before trying to get the parcel count: BUG workaround
IFeatureSelection pFeatSel = (IFeatureSelection)pFL;
ISelectionSet2 pSelSet = (ISelectionSet2)pFeatSel.SelectionSet;
if (pCadaSel.SelectedParcelCount == 0 && pSelSet.Count == 0)
{
MessageBox.Show("Please select some fabric parcels and try again.", "No Selection",
MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
ArcMap.Application.CurrentTool = null;
//Display the dialog
DialogResult pDialogResult = CalcStatedArea.ShowDialog();
if (pDialogResult != DialogResult.OK)
{
return;
}
m_bShowProgressor = (pSelSet.Count > 10) || pCadaSel.SelectedParcelCount > 10;
if (m_bShowProgressor)
{
m_pProgressorDialogFact = new ProgressDialogFactoryClass();
m_pTrackCancel = new CancelTrackerClass();
m_pStepProgressor = m_pProgressorDialogFact.Create(m_pTrackCancel, ArcMap.Application.hWnd);
pProgressorDialog = (IProgressDialog2)m_pStepProgressor;
m_pStepProgressor.MinRange = 1;
m_pStepProgressor.MaxRange = pCadaSel.SelectedParcelCount * 3; //(3 runs through the selection)
m_pStepProgressor.StepValue = 1;
pProgressorDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressSpiral;
}
m_pQF = new QueryFilterClass();
string sPref; string sSuff;
ISQLSyntax pSQLSyntax = (ISQLSyntax)pWS;
sPref = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
sSuff = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
//====== need to do this for all the parcel sublayers in the map that are part of the target fabric
//pEnumGSParcels should take care of this automatically
//but need to do this for line sublayer
if (m_bShowProgressor)
{
pProgressorDialog.ShowDialog();
m_pStepProgressor.Message = "Collecting parcel data...";
}
//Add the OIDs of all the selected parcels into a new feature IDSet
int tokenLimit = 995;
List <int> oidList = new List <int>();
Dictionary <int, string> dict_ParcelSelection2CalculatedArea = new Dictionary <int, string>();
pParcelsTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTParcels);
pEnumGSParcels.Reset();
IGSParcel pGSParcel = pEnumGSParcels.Next();
while (pGSParcel != null)
{
//Check if the cancel button was pressed. If so, stop process
if (m_bShowProgressor)
{
if (!m_pTrackCancel.Continue())
{
break;
}
}
int iDBId = pGSParcel.DatabaseId;
if (!oidList.Contains(iDBId))
{
oidList.Add(iDBId);
}
Marshal.ReleaseComObject(pGSParcel); //garbage collection
pGSParcel = pEnumGSParcels.Next();
if (m_bShowProgressor)
{
if (m_pStepProgressor.Position < m_pStepProgressor.MaxRange)
{
m_pStepProgressor.Step();
}
}
}
Marshal.ReleaseComObject(pEnumGSParcels); //garbage collection
if (m_bShowProgressor)
{
if (!m_pTrackCancel.Continue())
{
return;
}
}
string sSuffixUnit = CalcStatedArea.txtSuffix.Text;
int iAreaPrec = (int)CalcStatedArea.numDecPlaces.Value;
double dSqMPerUnit = 1;
if (CalcStatedArea.cboAreaUnit.FindStringExact("Acres") == CalcStatedArea.cboAreaUnit.SelectedIndex)
{
dSqMPerUnit = 4046.86;
}
if (CalcStatedArea.cboAreaUnit.FindStringExact("Hectares") == CalcStatedArea.cboAreaUnit.SelectedIndex)
{
dSqMPerUnit = 10000;
}
if (CalcStatedArea.cboAreaUnit.FindStringExact("Square Feet") == CalcStatedArea.cboAreaUnit.SelectedIndex)
{
dSqMPerUnit = 0.09290304;
}
if (CalcStatedArea.cboAreaUnit.FindStringExact("Square Feet US") == CalcStatedArea.cboAreaUnit.SelectedIndex)
{
dSqMPerUnit = 0.09290341;
}
if (m_bShowProgressor)
{
pProgressorDialog.ShowDialog();
m_pStepProgressor.Message = "Computing areas...";
}
List <string> sInClauseList0 = null;
m_pQF = new QueryFilterClass();
if (oidList.Count() > 0)
{
sInClauseList0 = Utils.InClauseFromOIDsList(oidList, tokenLimit);
foreach (string sInClause in sInClauseList0)
{
m_pQF.WhereClause = pParcelsTable.OIDFieldName + " IN (" + sInClause + ")";
CalculateStatedArea(m_pQF, pParcelsTable, pCadEd, m_pEd.Map.SpatialReference, dSqMPerUnit, sSuffixUnit,
iAreaPrec, ref dict_ParcelSelection2CalculatedArea, m_pTrackCancel);
if (m_bShowProgressor)
{
if (!m_pTrackCancel.Continue())
{
return;
}
}
}
}
else
{
return;
}
if (m_bShowProgressor)
{
if (!m_pTrackCancel.Continue())
{
return;
}
}
#region Create Cadastral Job
//string sTime = "";
//if (!bIsUnVersioned && !bIsFileBasedGDB)
//{
// //see if parcel locks can be obtained on the selected parcels. First create a job.
// DateTime localNow = DateTime.Now;
// sTime = Convert.ToString(localNow);
// ICadastralJob pJob = new CadastralJobClass();
// pJob.Name = sTime;
// pJob.Owner = System.Windows.Forms.SystemInformation.UserName;
// pJob.Description = "Interpolate Z values on selected features";
// try
// {
// Int32 jobId = pCadFabric.CreateJob(pJob);
// }
// catch (COMException ex)
// {
// if (ex.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_ALREADY_EXISTS)
// {
// MessageBox.Show("Job named: '" + pJob.Name + "', already exists");
// }
// else
// {
// MessageBox.Show(ex.Message);
// }
// return;
// }
//}
#endregion
//ILongArray pTempParcelsLongArray = new LongArrayClass();
//List<int> lstParcelChanges = Utils.FIDsetToLongArray(m_pFIDSetParcels, ref pTempParcelsLongArray, ref pParcelIds, m_pStepProgressor);
if (m_pEd.EditState == esriEditState.esriStateEditing)
{
try
{
m_pEd.StartOperation();
}
catch
{
m_pEd.AbortOperation();//abort any open edit operations and try again
m_pEd.StartOperation();
}
}
if (bUseNonVersionedEdit)
{
if (!Utils.StartEditing(pWS, bIsUnVersioned))
{
return;
}
}
//ICadastralFabricSchemaEdit2 pSchemaEd = (ICadastralFabricSchemaEdit2)pCadFabric;
//pSchemaEd.ReleaseReadOnlyFields(pParcelsTable, esriCadastralFabricTable.esriCFTParcels);
int idxParcelStatedArea = pParcelsTable.FindField("STATEDAREA");
string ParcelStatedAreaFieldName = pParcelsTable.Fields.get_Field(idxParcelStatedArea).Name;
if (m_bShowProgressor)
{
// pProgressorDialog.ShowDialog();
m_pStepProgressor.Message = "Updating parcel areas...";
}
IRow pTheFeatRow = null;
ICursor pUpdateCursor = null;
foreach (string sInClause in sInClauseList0)
{
m_pQF.WhereClause = pParcelsTable.OIDFieldName + " IN (" + sInClause + ")";
if (bUseNonVersionedEdit)
{
ITableWrite pTableWr = (ITableWrite)pParcelsTable; //used for unversioned table
pUpdateCursor = pTableWr.UpdateRows(m_pQF, false);
}
else
{
pUpdateCursor = pParcelsTable.Update(m_pQF, false);
}
pTheFeatRow = pUpdateCursor.NextRow();
while (pTheFeatRow != null)
{
string sAreaString = dict_ParcelSelection2CalculatedArea[pTheFeatRow.OID];
pTheFeatRow.set_Value(idxParcelStatedArea, sAreaString);
pTheFeatRow.Store();
Marshal.ReleaseComObject(pTheFeatRow); //garbage collection
if (m_bShowProgressor)
{
if (!m_pTrackCancel.Continue())
{
break;
}
}
pTheFeatRow = pUpdateCursor.NextRow();
}
Marshal.ReleaseComObject(pUpdateCursor); //garbage collection
if (m_bShowProgressor)
{
if (!m_pTrackCancel.Continue())
{
break;
}
}
}
m_pEd.StopOperation("Calculate Stated Area");
//pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTParcels);//set fields back to read-only
}
catch (Exception ex)
{
if (m_pEd != null)
{
AbortEdits(bIsUnVersioned, m_pEd, pWS);
}
MessageBox.Show(ex.Message);
}
finally
{
ArcMap.Application.CurrentTool = pTool;
m_pStepProgressor = null;
m_pTrackCancel = null;
if (pProgressorDialog != null)
{
pProgressorDialog.HideDialog();
}
RefreshMap(pActiveView, PolygonLyrArr);
ICadastralExtensionManager pCExMan = (ICadastralExtensionManager)pCadEd;
IParcelPropertiesWindow2 pPropW = (IParcelPropertiesWindow2)pCExMan.ParcelPropertiesWindow;
pPropW.RefreshAll();
//update the TOC
IMxDocument mxDocument = (ESRI.ArcGIS.ArcMapUI.IMxDocument)(ArcMap.Application.Document);
for (int i = 0; i < mxDocument.ContentsViewCount; i++)
{
IContentsView pCV = (IContentsView)mxDocument.get_ContentsView(i);
pCV.Refresh(null);
}
// refresh the attributes dialog
ISelectionEvents pSelEvents = (ISelectionEvents)m_pEd.Map;
pSelEvents.SelectionChanged();
if (bUseNonVersionedEdit)
{
pCadEd.CadastralFabricLayer = null;
PolygonLyrArr = null;
}
if (pMouseCursor != null)
{
pMouseCursor.SetCursor(0);
}
}
}
private void AbortEdits(bool bUseNonVersionedDelete, IEditor pEd, IWorkspace pWS)
{
clsFabricUtils FabricUTILS = new clsFabricUtils();
if (bUseNonVersionedDelete)
FabricUTILS.AbortEditing(pWS);
else
{
if (pEd != null)
{
if (pEd.EditState == esriEditState.esriStateEditing)
pEd.AbortOperation();
}
}
}
protected override void OnMouseDown(MouseEventArgs arg)
{
IFeatureLayer pPointLayer = null;
IFeatureLayer pLineLayer = null;
IArray pParcelLayers = null;
IFeatureLayer pControlLayer = null;
IFeatureLayer pLinePointLayer = null;
double dXYTol = 0.003;
clsFabricUtils FabricUTILS = new clsFabricUtils();
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
//first get the extension
UID pUID = new UIDClass();
pUID.Value = "{114D685F-99B7-4B63-B09F-6D1A41A4DDC1}";
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)ArcMap.Application.FindExtensionByCLSID(pUID);
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByCLSID(pUID);
//check if there is a Manual Mode "modify" job active ===========
ICadastralPacketManager pCadPacMan = (ICadastralPacketManager)pCadExtMan;
if (pCadPacMan.PacketOpen)
{
FabricUTILS.ExecuteCommand(m_CommUID);
MessageBox.Show("This tool cannot be used when there is an open parcel, construction, or job.\r\nPlease complete or discard the open items, and try again.");
return;
}
ICadastralFabric pCadFabric = null;
//if we're in an edit session then grab the target fabric
if (pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
else
{
FabricUTILS.ExecuteCommand(m_CommUID);
MessageBox.Show("This tool works on a parcel fabric in an edit session.\r\nPlease start editing and try again.");
return;
}
if (pCadFabric == null)
{//find the first fabric in the map
if (!FabricUTILS.GetFabricFromMap(ArcMap.Document.ActiveView.FocusMap, out pCadFabric))
{
FabricUTILS.ExecuteCommand(m_CommUID);
MessageBox.Show("No Parcel Fabric found in the map.\r\nPlease add a single fabric to the map, and try again.");
return;
}
}
IGeoDataset pGeoDS = (IGeoDataset)pCadFabric;
ISpatialReferenceTolerance pSpatRefTol = (ISpatialReferenceTolerance)pGeoDS.SpatialReference;
if (pSpatRefTol.XYToleranceValid == esriSRToleranceEnum.esriSRToleranceOK)
{
dXYTol = pSpatRefTol.XYTolerance;
}
IMouseCursor pMouseCursor = null;
ISpatialFilter pSpatFilt = null; //spatial filter query hinging off the dragged rectangle selection
IQueryFilter pQuFilter = null; //used for the non-spatial query for radial lines, as they have no geometry
IRubberBand2 pRubberRect = null;
IGeometryBag pGeomBag = null;
ITopologicalOperator5 pUnionedPolyine = null;
IPolygon pBufferedToolSelectGeometry = null; //geometry used to search for parents
IFIDSet pLineFIDs = null; //the FIDSet used to collect the lines that'll be deleted
IFIDSet pPointFIDs = null; // the FIDSet used to collect the points that'll be deleted
IFIDSet pLinePointFIDs = null; // the FIDSet used to collect the line-points that'll be deleted
List <int> pDeletedLinesPoints = new List <int>(); //list used to stage the ids for points that are referenced by lines
List <int> pUsedPoints = new List <int>(); //list used to collect pointids that are referenced by existing lines
List <int> CtrPointIDList = new List <int>(); //list for collecting the ids of center points
List <int> pParcelsList = new List <int>(); //used only to avoid adding duplicates to IN clause string for, based on ties to radial lines
List <int> pOrphanPointsList = new List <int>(); //list of orphan points defined from radial ines
List <int> pPointsInsideBoxList = new List <int>(); //list of parcels that exist and that intersect the drag-box
List <string> sFromToPair = new List <string>(); //list of from/to pairs for manging line points
List <int> pLineToParcelIDRef = new List <int>(); //list of parcel id refs stored on lines
IInvalidArea3 pInvArea = null;
IFeatureClass pLines = null;
IFeatureClass pPoints = null;
IFeatureClass pParcels = null;
IFeatureClass pLinePoints = null;
IWorkspace pWS = null;
try
{
#region define the rubber envelope geometry
pRubberRect = new RubberEnvelopeClass();
IGeometry ToolSelectEnvelope = pRubberRect.TrackNew(ArcMap.Document.ActiveView.ScreenDisplay, null);
if (ToolSelectEnvelope == null)
{
return;
}
ISegmentCollection pSegmentColl = new PolygonClass();
pSegmentColl.SetRectangle(ToolSelectEnvelope.Envelope);
IPolygon ToolSelectGeometry = (IPolygon)pSegmentColl;
if (pCadFabric == null)
{
return;
}
pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
#endregion
FabricUTILS.GetFabricSubLayersFromFabric(ArcMap.Document.ActiveView.FocusMap, pCadFabric,
out pPointLayer, out pLineLayer, out pParcelLayers, out pControlLayer,
out pLinePointLayer);
#region get tables and field indexes
pLines = (IFeatureClass)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTLines);
pPoints = (IFeatureClass)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTPoints);
pParcels = (IFeatureClass)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTParcels);
pLinePoints = (IFeatureClass)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTLinePoints);
string sPref = "";
string sSuff = "";
int iCtrPtFldIDX = pLines.FindField("CENTERPOINTID");
int iFromPtFldIDX = pLines.FindField("FROMPOINTID");
int iToPtFldIDX = pLines.FindField("TOPOINTID");
int iCatFldIDX = pLines.FindField("CATEGORY");
int iParcelIDX = pLines.FindField("PARCELID");
int iDistanceIDX = pLines.FindField("DISTANCE");
pWS = pLines.FeatureDataset.Workspace;
ISQLSyntax pSQLSyntax = (ISQLSyntax)pWS;
sPref = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
sSuff = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
pSpatFilt = new SpatialFilterClass();
pSpatFilt.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
pSpatFilt.Geometry = ToolSelectGeometry;
#endregion
#region center point
//need to make sure that center points are correctly handled for cases where the center point
//is inside the select box, but the curve itself is not. The following is used to build an
//IN CLAUSE for All the center points that are found within the tool's select geometry.
int iIsCtrPtIDX = pPoints.FindField("CENTERPOINT");
int iCount = 0;
int iCntCtrPoint = 0;
string sCtrPntIDList1 = "";
IFeatureCursor pFeatCursPoints = pPoints.Search(pSpatFilt, false);
IFeature pFeat7 = pFeatCursPoints.NextFeature();
while (pFeat7 != null)
{
iCount++;
int iVal = -1;
object Attr_val = pFeat7.get_Value(iIsCtrPtIDX);
if (Attr_val != DBNull.Value)
{
iVal = Convert.ToInt32(pFeat7.get_Value(iIsCtrPtIDX));
}
if (iVal == 1)
{
if (sCtrPntIDList1.Trim() == "")
{
sCtrPntIDList1 += pFeat7.OID.ToString();
}
else
{
sCtrPntIDList1 += "," + pFeat7.OID.ToString();
}
iCntCtrPoint++;
}
pPointsInsideBoxList.Add(pFeat7.OID); //used to check for orphan linepoints
pOrphanPointsList.Add(pFeat7.OID); //this gets whittled down till only "pure" orphan points remain
Marshal.ReleaseComObject(pFeat7);
pFeat7 = pFeatCursPoints.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursPoints);
#endregion
#region create convex hull of lines
//get the lines that intersect the search box and build a
//polygon search geometry being the convex hull of those lines.
IFeatureCursor pFeatCursLines = pLines.Search(pSpatFilt, false);
pGeomBag = new GeometryBagClass();
IGeometryCollection pGeomColl = (IGeometryCollection)pGeomBag;
IFeature pFeat1 = pFeatCursLines.NextFeature();
m_sDebug = "Add lines to Geometry Collection.";
string sParcelRefOnLines = "";
object missing = Type.Missing;
while (pFeat1 != null)
{
int iVal = (int)pFeat1.get_Value(iFromPtFldIDX);
string sFromTo = iVal.ToString() + ":";
if (pOrphanPointsList.Contains(iVal)) //Does this need to be done...will remove fail if it's not there?
{
pOrphanPointsList.Remove(iVal); //does this need to be in the if block?
}
iVal = (int)pFeat1.get_Value(iToPtFldIDX);
sFromTo += iVal.ToString();
if (pOrphanPointsList.Contains(iVal))
{
pOrphanPointsList.Remove(iVal);
}
sFromToPair.Add(sFromTo);
pGeomColl.AddGeometry(pFeat1.ShapeCopy, missing, missing);
if (sParcelRefOnLines.Trim() == "")
{
sParcelRefOnLines = pFeat1.get_Value(iParcelIDX).ToString();
}
else
{
sParcelRefOnLines += "," + pFeat1.get_Value(iParcelIDX).ToString();
}
Marshal.ReleaseComObject(pFeat1);
pFeat1 = pFeatCursLines.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursLines);
#endregion
#region Add Center Points for curves outside map extent
if (iCntCtrPoint > 999)
{
throw new InvalidOperationException("The Delete Orphans tool works with smaller amounts of data." + Environment.NewLine +
"Please try again, by selecting fewer fabric lines and points. (More than 1000 center points returned.)");
}
//If there is no line geometry found, and there are also no points found, then nothing to do...
if (pGeomColl.GeometryCount == 0 && iCount == 0)
{
return;
}
//Radial lines have no geometry so there is a special treatment for those;
//that special treatment takes two forms,
//1. if a circular arc is selected and it turns out that it is an orphan line, then we
//need to take down its radial lines, and its center point as well.
//2. if a center point is selected, we need to check if it's an orphan, by searching for its parent.
//The parent parcel can easily be well beyond the query rectangle, so the original
//search rectangle is buffered by the largest found radius distance, to make sure that all
//parent parcels are "find-able."
//The radial lines themselves are also needed; Get the radial lines from the Center Points
//CtrPt is always TO point, so find lines CATEGORY = 4 AND TOPOINT IN ()
string sRadialLineListParcelID = "";
string sRadialLinesID = "";
string sRadialLinePoints = "";
double dRadiusBuff = 0;
pQuFilter = new QueryFilterClass();
//Find all the radial lines based on the search query
if (sCtrPntIDList1.Trim() != "")
{
pQuFilter.WhereClause = "CATEGORY = 4 AND TOPOINTID IN (" + sCtrPntIDList1 + ")";
//add all the *references* to Parcel ids for the radial lines,
//and add the ID's of the lines
IFeatureCursor pFeatCursLines8 = pLines.Search(pQuFilter, false);
IFeature pFeat8 = pFeatCursLines8.NextFeature();
while (pFeat8 != null)
{
object Attr_val = pFeat8.get_Value(iDistanceIDX);
double dVal = 0;
if (Attr_val != DBNull.Value)
{
dVal = Convert.ToDouble(Attr_val);
}
dRadiusBuff = dRadiusBuff > dVal ? dRadiusBuff : dVal;
int iVal = Convert.ToInt32(pFeat8.get_Value(iParcelIDX));
if (!pParcelsList.Contains(iVal))
{
if (sRadialLineListParcelID.Trim() == "")
{
sRadialLineListParcelID += Convert.ToString(iVal);
}
else
{
sRadialLineListParcelID += "," + Convert.ToString(iVal);
}
}
pParcelsList.Add(iVal);
//pOrphanPointsList is used for "Pure Orphan point" detection
//meaning that these are points that do not have ANY line, not even an orphan line.
iVal = (int)pFeat8.get_Value(iFromPtFldIDX);
if (pOrphanPointsList.Contains(iVal))
{
pOrphanPointsList.Remove(iVal);
}
iVal = (int)pFeat8.get_Value(iToPtFldIDX);
if (pOrphanPointsList.Contains(iVal))
{
pOrphanPointsList.Remove(iVal);
}
if (sRadialLinesID.Trim() == "")
{
sRadialLinesID += Convert.ToString(iVal);
}
else
{
sRadialLinesID += "," + Convert.ToString(iVal);
}
//Add from point to list
if (sRadialLinePoints.Trim() == "")
{
sRadialLinePoints += Convert.ToString(pFeat8.get_Value(iFromPtFldIDX));
}
else
{
sRadialLinePoints += "," + Convert.ToString(pFeat8.get_Value(iFromPtFldIDX));
}
//Add To point to list
sRadialLinePoints += "," + Convert.ToString(pFeat8.get_Value(iToPtFldIDX));
Marshal.ReleaseComObject(pFeat8);
pFeat8 = pFeatCursLines8.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursLines8);
//create a polygon goeometry that is a buffer of the selection rectangle expanded
//to the greatest radius of all the radial lines found.
ITopologicalOperator topologicalOperator = (ITopologicalOperator)ToolSelectGeometry;
pBufferedToolSelectGeometry = topologicalOperator.Buffer(dRadiusBuff) as IPolygon;
}
else
{
pQuFilter.WhereClause = "";
}
#endregion
#region OrphanLines
if (pGeomColl.GeometryCount != 0)
{
pUnionedPolyine = new PolylineClass();
pUnionedPolyine.ConstructUnion((IEnumGeometry)pGeomBag);
ITopologicalOperator pTopoOp = (ITopologicalOperator)pUnionedPolyine;
IGeometry pConvexHull = pTopoOp.ConvexHull();
//With this convex hull, do a small buffer,
//theis search geometry is used as a spatial query on the parcel polygons
//and also on the parcel lines, to build IN Clauses
pTopoOp = (ITopologicalOperator)pConvexHull;
IGeometry pBufferedConvexHull = pTopoOp.Buffer(10 * dXYTol);
if (pBufferedToolSelectGeometry != null)
{
pTopoOp = (ITopologicalOperator)pBufferedToolSelectGeometry;
IGeometry pUnionPolygon = pTopoOp.Union(pBufferedConvexHull);
pSpatFilt.Geometry = pUnionPolygon;
}
else
{
pSpatFilt.Geometry = pBufferedConvexHull;
}
}
else
{
if (pQuFilter.WhereClause.Trim() == "" && pBufferedToolSelectGeometry == null)
{
pSpatFilt.Geometry = ToolSelectGeometry;
}
else
{
pSpatFilt.Geometry = pBufferedToolSelectGeometry;
}
}
IColor pColor = new RgbColorClass();
pColor.RGB = System.Drawing.Color.Blue.ToArgb();
IScreenDisplay pScreenDisplay = ArcMap.Document.ActiveView.ScreenDisplay;
FabricUTILS.FlashGeometry(pSpatFilt.Geometry, pScreenDisplay, pColor, 5, 100);
pSpatFilt.SearchOrder = esriSearchOrder.esriSearchOrderSpatial;
m_sDebug = "Searching Parcels table.";
pInvArea = new InvalidAreaClass();
IFeatureCursor pFeatCursParcels = pParcels.Search(pSpatFilt, false);
IFeature pFeat2 = pFeatCursParcels.NextFeature();
string sParcelIDList = "";
iCount = 0;
//create the "NOT IN" CLAUSE for parcels that exist in the DB and that are within the search area
//Will be used as a search on lines to get the Orphan Lines
while (pFeat2 != null)
{
iCount++;
if (sParcelIDList.Trim() == "")
{
sParcelIDList += pFeat2.OID.ToString();
}
else
{
sParcelIDList += "," + pFeat2.OID.ToString();
}
Marshal.ReleaseComObject(pFeat2);
if (iCount > 999)
{
break;
}
pFeat2 = pFeatCursParcels.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursParcels);
//if we have more than 999 in clause tokens, there will be problems on Oracle.
//Since this is an interactive tool, we expect it not to be used on a large amount of data.
//for this reason, the following message is displayed if more than 999 parcels are returned in this query.
//TODO: for the future this can be made to work on larger sets of data.
if (iCount > 999)
{
throw new InvalidOperationException("The Delete Orphans tool works with smaller amounts of data." + Environment.NewLine +
"Please try again, by selecting fewer fabric lines and points. (More than 1000 parcels returned.)");
}
m_sDebug = "Building the used points list.";
//This first pass contains all references to points found within the parent parcel search buffer
//Later, points are removed from this list
IFeatureCursor pFeatCursLargerLineSet = pLines.Search(pSpatFilt, false);
IFeature pFeat3 = pFeatCursLargerLineSet.NextFeature();
while (pFeat3 != null)
{
iCount++;
object Attr_val = pFeat3.get_Value(iCtrPtFldIDX);
if (Attr_val != DBNull.Value)
{
pUsedPoints.Add(Convert.ToInt32(Attr_val)); //add center point
}
int iVal = (int)pFeat3.get_Value(iFromPtFldIDX);
pUsedPoints.Add(iVal);//add from point
iVal = (int)pFeat3.get_Value(iToPtFldIDX);
pUsedPoints.Add(iVal);//add to point
Marshal.ReleaseComObject(pFeat3);
pFeat3 = pFeatCursLargerLineSet.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursLargerLineSet);
//pUsedPoints list is at this stage, references to points for all lines found within the search area.
//use the IN clause of the parcel ids to search for lines within
//the original search box, and that are also orphans that do not have a parent parcel.
pSpatFilt.WhereClause = "";
pSpatFilt.Geometry = ToolSelectGeometry;
pSpatFilt.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
pSpatFilt.SearchOrder = esriSearchOrder.esriSearchOrderSpatial;
IFeatureCursor pFeatCursor = null;
if (pGeomColl.GeometryCount == 0)
{
if (sParcelIDList.Trim().Length > 0 && sCtrPntIDList1.Trim().Length > 0)
{
pQuFilter.WhereClause = "(PARCELID NOT IN (" + sParcelIDList +
")) AND (CATEGORY = 4 AND TOPOINTID IN (" + sCtrPntIDList1 + "))";
pFeatCursor = pLines.Search(pQuFilter, false);
}
else if (sParcelIDList.Trim().Length == 0 && sCtrPntIDList1.Trim().Length > 0)
{
pQuFilter.WhereClause = "CATEGORY = 4 AND TOPOINTID IN (" + sCtrPntIDList1 + ")";
pFeatCursor = pLines.Search(pQuFilter, false);
}
}
else
{//do a spatial query
if (sParcelIDList.Trim().Length > 0)
{
pSpatFilt.WhereClause = "PARCELID NOT IN (" + sParcelIDList + ")";
}
else
{
pSpatFilt.WhereClause = "";
}
pFeatCursor = pLines.Search(pSpatFilt, false);
}
m_sDebug = "Collecting lines to be deleted.";
//start collecting the lines that need to be deleted
iCount = 0;
int iCtrPointCount = 0;
string sCtrPointIDList = "";
string sLineParcelIDReference = "";
//Feature cursor is lines that are NOT IN the ParcelIDList
if (pFeatCursor != null)
{
pLineFIDs = new FIDSetClass();
IFeature pFeat4 = pFeatCursor.NextFeature();
while (pFeat4 != null)
{
iCount++;
pLineFIDs.Add(pFeat4.OID);
int iParcRef = Convert.ToInt32(pFeat4.get_Value(iParcelIDX));
if (sLineParcelIDReference.Trim() == "")
{
sLineParcelIDReference = iParcRef.ToString();
}
else
{
if (!pLineToParcelIDRef.Contains(iParcRef))
{
sLineParcelIDReference += "," + iParcRef.ToString();
}
}
pLineToParcelIDRef.Add(iParcRef);
pInvArea.Add((IObject)pFeat4);
//now for this line, get it's points
//first add the center point reference if there is one
object Attr_val = pFeat4.get_Value(iCtrPtFldIDX);
if (Attr_val != DBNull.Value)
{
iCtrPointCount++;
int iCtrPointID = Convert.ToInt32(Attr_val);
pDeletedLinesPoints.Add(iCtrPointID); //add this line's center point
pUsedPoints.Remove(iCtrPointID);
if (sCtrPointIDList.Trim() == "")
{
sCtrPointIDList = iCtrPointID.ToString();
}
else
{
if (CtrPointIDList.Contains(iCtrPointID))
{
iCtrPointCount--;
}
else
{
sCtrPointIDList += "," + iCtrPointID.ToString();
}
}
CtrPointIDList.Add(iCtrPointID);//to keep track of repeats
}
//and also add the FROM and TO point references if they exist
int iVal = (int)pFeat4.get_Value(iFromPtFldIDX);
pDeletedLinesPoints.Add(iVal);//add FROM point
if (pGeomColl.GeometryCount > 0)
{
pUsedPoints.Remove(iVal);
}
iVal = (int)pFeat4.get_Value(iToPtFldIDX);
pDeletedLinesPoints.Add(iVal);//add TO point
if (pGeomColl.GeometryCount > 0)
{
pUsedPoints.Remove(iVal);
}
Marshal.ReleaseComObject(pFeat4);
if (iCtrPointCount > 999)
{
break;
}
pFeat4 = pFeatCursor.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursor);
}
if (iCtrPointCount > 999)
{
throw new InvalidOperationException("The Delete Orphans tool works with smaller amounts of data." + Environment.NewLine +
"Please try again, by selecting fewer fabric lines and points. (More than 1000 center points returned.)");
}
m_sDebug = "Adding orphan radial lines to list.";
if (sCtrPointIDList.Trim().Length > 0)
{
//add the Radial lines at each end of the curves using the collected CtrPtIDs
//CtrPt is always TO point, so find lines CATEGORY = 4 AND TOPOINT IN ()
pQuFilter.WhereClause = "CATEGORY = 4 AND TOPOINTID IN (" + sCtrPointIDList + ")";
pFeatCursor = pLines.Search(pQuFilter, false);
IFeature pFeat5 = pFeatCursor.NextFeature();
while (pFeat5 != null)
{
pLineFIDs.Add(pFeat5.OID);
int iParcRef = Convert.ToInt32(pFeat5.get_Value(iParcelIDX));
pLineToParcelIDRef.Add(iParcRef);
if (sLineParcelIDReference.Trim() == "")
{
sLineParcelIDReference = iParcRef.ToString();
}
else
{
if (!pLineToParcelIDRef.Contains(iParcRef))
{
sLineParcelIDReference += "," + iParcRef.ToString();
}
}
Marshal.ReleaseComObject(pFeat5);
pFeat5 = pFeatCursor.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursor);
}
else
{
pQuFilter.WhereClause = "";
}
//refine the DeletedLinesPoints list
foreach (int i in pUsedPoints)
{
if (pDeletedLinesPoints.Contains(i))
{
do
{
} while (pDeletedLinesPoints.Remove(i));
}
}
//add the points to a new FIDSet
pPointFIDs = new FIDSetClass();
foreach (int i in pDeletedLinesPoints)
{
pPointFIDs.Add(i);
}
#endregion
#region OrphanPoints
//We already know which points to delete based on taking down the orphan lines.
//We need to still add to the points FIDSet those points that are "pure" ophan points
//as defined for the pOrphanPointsList variable.
//and add the orphan points to the points FIDSet
foreach (int i in pOrphanPointsList)
{
bool bFound = false;
pPointFIDs.Find(i, out bFound);
if (!bFound)
{
pPointFIDs.Add(i);
}
}
#endregion
#region orphan Line points
//next check for orphan line-points
//the line-point is deleted if there is no underlying point
//or if the from and to point references do not exist.
pSpatFilt.WhereClause = "";
pSpatFilt.Geometry = ToolSelectGeometry;
IFeatureCursor pFeatCursLinePoints = pLinePoints.Search(pSpatFilt, false);
IFeature pLPFeat = pFeatCursLinePoints.NextFeature();
int iLinePtPointIdIdx = pLinePoints.FindField("LINEPOINTID");
int iLinePtFromPtIdIdx = pLinePoints.FindField("FROMPOINTID");
int iLinePtToPtIdIdx = pLinePoints.FindField("TOPOINTID");
pLinePointFIDs = new FIDSetClass();
while (pLPFeat != null)
{
bool bExistsA = true;
bool bExists1 = true;
bool bExists2 = true;
bool bExists3 = true;
int iVal = (int)pLPFeat.get_Value(iLinePtPointIdIdx);
pPointFIDs.Find(iVal, out bExists1);
if (!pPointsInsideBoxList.Contains(iVal))
{
bExistsA = false;
}
iVal = (int)pLPFeat.get_Value(iLinePtFromPtIdIdx);
string sFrom = iVal.ToString();
pPointFIDs.Find(iVal, out bExists2);
iVal = (int)pLPFeat.get_Value(iLinePtToPtIdIdx);
string sTo = iVal.ToString();
pPointFIDs.Find(iVal, out bExists3);
int iOID = pLPFeat.OID;
if (bExists1 || bExists2 || bExists3)
{
pLinePointFIDs.Add(iOID);
}
if (!sFromToPair.Contains(sFrom + ":" + sTo) && !sFromToPair.Contains(sTo + ":" + sFrom))
{
pLinePointFIDs.Find(iOID, out bExists1);
if (!bExists1)
{
pLinePointFIDs.Add(iOID);
}
}
//if (!bExistsA || !bExistsB || !bExistsC)
if (!bExistsA)
{
bool bFound = true;
pLinePointFIDs.Find(iOID, out bFound);
if (!bFound)
{
pLinePointFIDs.Add(iOID);
}
}
pPointsInsideBoxList.Contains(iVal);
Marshal.ReleaseComObject(pLPFeat);
pLPFeat = pFeatCursLinePoints.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursLinePoints);
#endregion
#region Refine the lines that are on the delete list
//next step is to refine and double-check to make sure that the lines that are on the delete list
//do not have a parcel record somewhere else (not spatially connected to the line) (example unjoined, or bad geom)
string sFreshlyFoundParcels = "";
if (sLineParcelIDReference.Trim() != "")
{
pQuFilter.WhereClause = sPref + pParcels.OIDFieldName + sSuff + " IN (" + sLineParcelIDReference + ")";
pFeatCursor = pParcels.Search(pQuFilter, false);
IFeature pFeat6 = pFeatCursor.NextFeature();
while (pFeat6 != null)
{
int iOID = pFeat6.OID;
if (sFreshlyFoundParcels.Trim() == "")
{
sFreshlyFoundParcels = iOID.ToString();
}
else
{
sFreshlyFoundParcels += "," + iOID.ToString();
}
Marshal.ReleaseComObject(pFeat6);
pFeat6 = pFeatCursor.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursor);
if (sFreshlyFoundParcels.Trim() != "")
{
pQuFilter.WhereClause = "PARCELID IN (" + sFreshlyFoundParcels + ")";
pFeatCursor = pLines.Search(pQuFilter, false);
IFeature pFeat9 = pFeatCursor.NextFeature();
while (pFeat9 != null)
{
int iOID = pFeat9.OID;
bool bIsHere = false;
pLineFIDs.Delete(iOID);
int iVal = Convert.ToInt32(pFeat9.get_Value(iFromPtFldIDX));
pPointFIDs.Find(iVal, out bIsHere);
if (bIsHere)
{
pPointFIDs.Delete(iVal);
}
iVal = Convert.ToInt32(pFeat9.get_Value(iToPtFldIDX));
pPointFIDs.Find(iVal, out bIsHere);
if (bIsHere)
{
pPointFIDs.Delete(iVal);
}
Marshal.ReleaseComObject(pFeat9);
pFeat9 = pFeatCursor.NextFeature();
}
Marshal.FinalReleaseComObject(pFeatCursor);
}
}
#endregion
#region Make sure the points on the delete list are not part of a construction
//For post 10.0, Make sure the points on the delete list are not part of a construction if they are then null geometry
//pQuFilter.WhereClause=pLines.LengthField.Name + " = 0 AND CATEGORY <> 4";
//IFeatureCursor pFeatCursLines101 = pLines.Search(pQuFilter, false);
//this would open a new cursor and do a query on the entire
#endregion
#region report results and do edits
dlgReport Report = new dlgReport();
//Display the dialog
System.Drawing.Color BackColorNow = Report.textBox1.BackColor;
if (iCount == 0 && pPointFIDs.Count() == 0 && pLinePointFIDs.Count() == 0)
{
Report.textBox1.BackColor = System.Drawing.Color.LightGreen;
Report.textBox1.Text = "Selected area has no orphan lines or points.";
}
else
{
int iCount1 = 0;
int iCount2 = 0;
int iCount3 = 0;
if (pLineFIDs != null)
{
iCount1 = pLineFIDs.Count();
}
if (pPointFIDs != null)
{
iCount2 = pPointFIDs.Count();
}
if (pLinePointFIDs != null)
{
iCount3 = pLinePointFIDs.Count();
}
iCount = iCount1 + iCount2 + iCount3;
if (iCount > 0)
{
pEd.StartOperation();
FabricUTILS.DeleteRowsByFIDSet((ITable)pLines, pLineFIDs, null, null);
FabricUTILS.DeleteRowsByFIDSet((ITable)pPoints, pPointFIDs, null, null);
if (pPointFIDs.Count() > 0)
{
//now need to update the control points associated with any deleted points.
ICadastralFabricSchemaEdit2 pSchemaEd = (ICadastralFabricSchemaEdit2)pCadFabric;
ITable pControlTable = pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTControl);
int idxNameFldOnControl = pControlTable.FindField("POINTID");
string ControlNameFldName = pControlTable.Fields.get_Field(idxNameFldOnControl).Name;
int i;
List <int> pPointFIDList = new List <int>();
pPointFIDs.Reset();
pPointFIDs.Next(out i);
while (i > -1)
{
pPointFIDList.Add(i);
pPointFIDs.Next(out i);
}
List <string> InClausePointsNotConnectedToLines = FabricUTILS.InClauseFromOIDsList(pPointFIDList, 995);
pQuFilter.WhereClause = ControlNameFldName + " IN (" + InClausePointsNotConnectedToLines[0] + ")";
pSchemaEd.ReleaseReadOnlyFields(pControlTable, esriCadastralFabricTable.esriCFTControl); //release safety-catch
if (!FabricUTILS.ResetControlAssociations(pControlTable, pQuFilter, false))
{
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTControl);//set safety back on
pEd.AbortOperation();
return;
}
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTControl);//set safety back on
}
pQuFilter.WhereClause = "";
FabricUTILS.DeleteRowsByFIDSet((ITable)pLinePoints, pLinePointFIDs, null, null);
pEd.StopOperation("Delete " + iCount.ToString() + " orphans");
Report.textBox1.Text = "Deleted:";
if (iCount1 > 0)
{
Report.textBox1.Text += Environment.NewLine + iCount1.ToString() + " orphaned lines";
}
if (iCount2 > 0)
{
Report.textBox1.Text += Environment.NewLine + iCount2.ToString() + " orphaned points";
}
if (iCount3 > 0)
{
Report.textBox1.Text += Environment.NewLine + iCount3.ToString() + " orphaned line points";
}
}
if (sFreshlyFoundParcels.Trim() != "")
{
if (Report.textBox1.Text.Trim() != "")
{
Report.textBox1.Text += Environment.NewLine;
}
Report.textBox1.Text += "Info: Line(s) that you selected are not directly" +
Environment.NewLine + "touching a parent parcel geometry. Check parcels with OIDs:" +
sFreshlyFoundParcels;
}
}
IArea pArea = (IArea)ToolSelectGeometry;
if (pArea.Area > 0)
{
SetDialogLocationAtPoint(Report, pArea.Centroid);
}
DialogResult pDialogResult = Report.ShowDialog();
Report.textBox1.BackColor = BackColorNow;
pInvArea.Display = ArcMap.Document.ActiveView.ScreenDisplay;
pInvArea.Invalidate((short)esriScreenCache.esriAllScreenCaches);
if (pPointLayer != null)
{
ArcMap.Document.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography,
pPointLayer, ArcMap.Document.ActiveView.Extent);
}
#endregion
}
catch (Exception ex)
{
if (pEd != null)
{
pEd.AbortOperation();
}
MessageBox.Show(ex.Message + Environment.NewLine + m_sDebug, "Delete Orphans Tool");
this.OnDeactivate();
}
#region Final Cleanup
finally
{
pDeletedLinesPoints.Clear();
pDeletedLinesPoints = null;
pUsedPoints.Clear();
pUsedPoints = null;
CtrPointIDList.Clear();
CtrPointIDList = null;
pParcelsList.Clear();
pParcelsList = null;
pOrphanPointsList.Clear();
pOrphanPointsList = null;
pPointsInsideBoxList.Clear();
pPointsInsideBoxList = null;
pLineToParcelIDRef.Clear();
pLineToParcelIDRef = null;
sFromToPair.Clear();
sFromToPair = null;
FabricUTILS = null;
}
#endregion
}
protected override void OnClick()
{
IMouseCursor pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
//get the plans
UID pUID = new UIDClass();
pUID.Value = "{114D685F-99B7-4B63-B09F-6D1A41A4DDC1}";
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)ArcMap.Application.FindExtensionByCLSID(pUID);
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByCLSID(pUID);
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
dlgEmptyPlansList pPlansListDialog = new dlgEmptyPlansList();
IActiveView pActiveView = ArcMap.Document.ActiveView;
IMap pMap = pActiveView.FocusMap;
ICadastralFabric pCadFabric = null;
clsFabricUtils FabricUTILS = new clsFabricUtils();
//if we're in an edit session then grab the target fabric
if (pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
if (pCadFabric == null)
{
//find the first fabric in the map
if (!FabricUTILS.GetFabricFromMap(pMap, out pCadFabric))
{
MessageBox.Show
("No Parcel Fabric found in the map.\r\nPlease add a single fabric to the map, and try again.");
return;
}
}
ITable pPlansTable = null;
if (pCadFabric != null)
{
pPlansTable = pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTPlans);
}
else
{
return;
}
IDataset pDS = (IDataset)pPlansTable;
IWorkspace pWS = pDS.Workspace;
bool bIsFileBasedGDB;
bool bIsUnVersioned;
bool bUseNonVersionedEdit;
if (!(FabricUTILS.SetupEditEnvironment(pWS, pCadFabric, pEd,
out bIsFileBasedGDB, out bIsUnVersioned, out bUseNonVersionedEdit)))
{
return;
}
IFIDSet pEmptyPlans = null;
if (!FindEmptyPlans(pCadFabric, null, null, out pEmptyPlans))
{
return;
}
//Fill the list on the dialog
AddEmptyPlansToList(pCadFabric, pEmptyPlans, pPlansListDialog);
//Display the dialog
DialogResult pDialogResult = pPlansListDialog.ShowDialog();
if (pDialogResult != DialogResult.OK)
{
return;
}
IArray array = (IArray)pPlansListDialog.checkedListBox1.Tag;
IFIDSet pPlansToDelete = new FIDSetClass();
foreach (int checkedItemIndex in pPlansListDialog.checkedListBox1.CheckedIndices)
{
Int32 iPlansID = (Int32)array.get_Element(checkedItemIndex);
if (iPlansID > -1)
{
pPlansToDelete.Add(iPlansID);
}
}
if (bUseNonVersionedEdit)
{
FabricUTILS.DeleteRowsUnversioned(pWS, pPlansTable, pPlansToDelete, null, null);
}
else
{
try
{
try
{
pEd.StartOperation();
}
catch
{
pEd.AbortOperation();//abort any open edit operations and try again
pEd.StartOperation();
}
FabricUTILS.DeleteRowsByFIDSet(pPlansTable, pPlansToDelete, null, null);
pEd.StopOperation("Delete Empty Plans");
}
catch (COMException ex)
{
MessageBox.Show(Convert.ToString(ex.ErrorCode));
pEd.AbortOperation();
}
}
}
protected override void OnClick()
{
m_bNoUpdates = false;
m_sReport = "Direction Inverse Report:";
IEditor m_pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
if (m_pEd.EditState == esriEditState.esriStateNotEditing)
{
MessageBox.Show("Please start editing first, and try again.", "Start Editing");
return;
}
UID pUID = new UIDClass();
pUID.Value = "{114D685F-99B7-4B63-B09F-6D1A41A4DDC1}";
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)ArcMap.Application.FindExtensionByCLSID(pUID);
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByCLSID(pUID);
//check if there is a Manual Mode "modify" job active ===========
ICadastralPacketManager pCadPacMan = (ICadastralPacketManager)pCadExtMan;
if (pCadPacMan.PacketOpen)
{
MessageBox.Show("The Delete Parcels command cannot be used when there is an open job.\r\nPlease finish or discard the open job, and try again.",
"Delete Selected Parcels");
return;
}
try
{
IEditProperties2 pEditorProps2 = (IEditProperties2)m_pEd;
IArray LineLyrArr;
IMap pMap = m_pEd.Map;
ICadastralFabric pCadFabric = null;
//ISpatialReference pSpatRef = m_pEd.Map.SpatialReference;
//IProjectedCoordinateSystem2 pPCS = null;
IActiveView pActiveView = ArcMap.Document.ActiveView;
//double dMetersPerUnit = 1;
//if (pSpatRef == null)
// ;
//else if (pSpatRef is IProjectedCoordinateSystem2)
//{
// pPCS = (IProjectedCoordinateSystem2)pSpatRef;
// string sUnit = pPCS.CoordinateUnit.Name;
// if (sUnit.Contains("Foot") && sUnit.Contains("US"))
// sUnit = "U.S. Feet";
// dMetersPerUnit = pPCS.CoordinateUnit.MetersPerUnit;
//}
IAngularConverter pAngConv = new AngularConverterClass();
Utilities Utils = new Utilities();
if (!Utils.GetFabricSubLayers(pMap, esriCadastralFabricTable.esriCFTLines, out LineLyrArr))
{
return;
}
//if we're in an edit session then grab the target fabric
if (m_pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
if (pCadFabric == null)
{//find the first fabric in the map
if (!Utils.GetFabricFromMap(pMap, out pCadFabric))
{
MessageBox.Show
("No Parcel Fabric found in the map.\r\nPlease add a single fabric to the map, and try again.");
return;
}
}
List <int> lstLineIds = new List <int>();
IFeatureClass pFabricLinesFC = (IFeatureClass)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTLines);
int idxParcelIDFld = pFabricLinesFC.Fields.FindField("ParcelID");
int idxCENTERPTID = pFabricLinesFC.Fields.FindField("CenterPointID");
int idxRADIUS = pFabricLinesFC.Fields.FindField("Radius");
bool bFieldsPresent = true;
if (idxParcelIDFld == -1)
{
bFieldsPresent = false;
}
if (idxCENTERPTID == -1)
{
bFieldsPresent = false;
}
if (idxRADIUS == -1)
{
bFieldsPresent = false;
}
if (!bFieldsPresent)
{
MessageBox.Show("Fields missing.");
return;
}
Dictionary <int, List <string> > dictLineToCurveNeighbourData = new Dictionary <int, List <string> >();
m_pFIDSetParcels = new FIDSet();
for (int i = 0; i < LineLyrArr.Count; i++)
{
IFeatureSelection pFeatSel = LineLyrArr.Element[i] as IFeatureSelection;
ISelectionSet pSelSet = pFeatSel.SelectionSet;
ICursor pCursor = null;
pSelSet.Search(null, false, out pCursor);
IFeature pLineFeat = pCursor.NextRow() as IFeature;
while (pLineFeat != null)
{
if (!lstLineIds.Contains(pLineFeat.OID))
{
IGeometry pGeom = pLineFeat.ShapeCopy;
ISegmentCollection pSegColl = pGeom as ISegmentCollection;
ISegment pSeg = null;
if (pSegColl.SegmentCount == 1)
{
pSeg = pSegColl.get_Segment(0);
}
else
{
//todo: but for now, only deals with single segment short segments
Marshal.ReleaseComObject(pLineFeat);
pLineFeat = pCursor.NextRow() as IFeature;
continue;
}
//check geometry for circular arc
if (pSeg is ICircularArc)
{
object dVal1 = pLineFeat.get_Value(idxRADIUS);
object dVal2 = pLineFeat.get_Value(idxCENTERPTID);
ICircularArc pCircArc = pSeg as ICircularArc;
if (dVal1 != DBNull.Value && dVal2 != DBNull.Value)
{
Marshal.ReleaseComObject(pLineFeat);
pLineFeat = pCursor.NextRow() as IFeature;
continue;
}
}
//query near lines
int iFoundTangent = 0;
List <string> sCurveInfoFromNeighbours = new List <string>();
if (Utils.HasTangentCurveMatchFeatures(pFabricLinesFC, (IPolycurve)pGeom, "", 1.5, 0.033, 1, (pSeg.Length * 1.1),
out iFoundTangent, ref sCurveInfoFromNeighbours))
{
lstLineIds.Add(pLineFeat.OID);
int j = (int)pLineFeat.get_Value(idxParcelIDFld);
m_pFIDSetParcels.Add(j);
dictLineToCurveNeighbourData.Add(pLineFeat.OID, sCurveInfoFromNeighbours);
}
if (iFoundTangent == 1) //if there's only one tangent look further afield
{
int iFoundLinesCount = 0;
int iFoundParallel = 0;
if (Utils.HasParallelCurveMatchFeatures(pFabricLinesFC, (IPolycurve)pGeom, "", 1.5, 70,
out iFoundLinesCount, out iFoundParallel, ref sCurveInfoFromNeighbours))
{
if (!dictLineToCurveNeighbourData.ContainsKey(pLineFeat.OID))
{
dictLineToCurveNeighbourData.Add(pLineFeat.OID, sCurveInfoFromNeighbours);
}
}
}
}
Marshal.ReleaseComObject(pLineFeat);
pLineFeat = pCursor.NextRow() as IFeature;
}
Marshal.ReleaseComObject(pCursor);
}
#region line to curve candidate analysis
if (lstLineIds.Count == 0)
{
return;
}
RefineToBestRadiusAndCenterPoint(dictLineToCurveNeighbourData);
#endregion
if (dictLineToCurveNeighbourData.Count == 0)
{
return;
}
bool bIsFileBasedGDB = false; bool bIsUnVersioned = false; bool bUseNonVersionedDelete = false;
IWorkspace pWS = m_pEd.EditWorkspace;
IProgressDialog2 pProgressorDialog = null;
IMouseCursor pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
if (!Utils.SetupEditEnvironment(pWS, pCadFabric, m_pEd, out bIsFileBasedGDB,
out bIsUnVersioned, out bUseNonVersionedDelete))
{
return;
}
#region Create Cadastral Job
string sTime = "";
if (!bIsUnVersioned && !bIsFileBasedGDB)
{
//see if parcel locks can be obtained on the selected parcels. First create a job.
DateTime localNow = DateTime.Now;
sTime = Convert.ToString(localNow);
ICadastralJob pJob = new CadastralJobClass();
pJob.Name = sTime;
pJob.Owner = System.Windows.Forms.SystemInformation.UserName;
pJob.Description = "Convert lines to curves";
try
{
Int32 jobId = pCadFabric.CreateJob(pJob);
}
catch (COMException ex)
{
if (ex.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_ALREADY_EXISTS)
{
MessageBox.Show("Job named: '" + pJob.Name + "', already exists");
}
else
{
MessageBox.Show(ex.Message);
}
return;
}
}
#endregion
#region Test for Edit Locks
ICadastralFabricLocks pFabLocks = (ICadastralFabricLocks)pCadFabric;
//only need to get locks for parcels that have lines that are to be changed
int[] pParcelIds = new int[m_pFIDSetParcels.Count()];
ILongArray pParcelsToLock = new LongArrayClass();
Utils.FIDsetToLongArray(m_pFIDSetParcels, ref pParcelsToLock, ref pParcelIds, m_pStepProgressor);
if (!bIsUnVersioned && !bIsFileBasedGDB)
{
pFabLocks.LockingJob = sTime;
ILongArray pLocksInConflict = null;
ILongArray pSoftLcksInConflict = null;
if (m_bShowProgressor && !bIsFileBasedGDB)
{
m_pStepProgressor.Message = "Testing for edit locks on parcels...";
}
try
{
pFabLocks.AcquireLocks(pParcelsToLock, true, ref pLocksInConflict, ref pSoftLcksInConflict);
}
catch (COMException pCOMEx)
{
if (pCOMEx.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_LOCK_ALREADY_EXISTS ||
pCOMEx.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_CURRENTLY_EDITED)
{
MessageBox.Show("Edit Locks could not be acquired on all selected parcels.");
// since the operation is being aborted, release any locks that were acquired
pFabLocks.UndoLastAcquiredLocks();
}
else
{
MessageBox.Show(pCOMEx.Message + Environment.NewLine + Convert.ToString(pCOMEx.ErrorCode));
}
return;
}
}
#endregion
if (m_pEd.EditState == esriEditState.esriStateEditing)
{
try
{
m_pEd.StartOperation();
}
catch
{
m_pEd.AbortOperation();//abort any open edit operations and try again
m_pEd.StartOperation();
}
}
if (bUseNonVersionedDelete)
{
if (!Utils.StartEditing(pWS, bIsUnVersioned))
{
return;
}
}
ICadastralFabricSchemaEdit2 pSchemaEd = (ICadastralFabricSchemaEdit2)pCadFabric;
pSchemaEd.ReleaseReadOnlyFields((ITable)pFabricLinesFC, esriCadastralFabricTable.esriCFTLines); //release for edits
m_pQF = new QueryFilter();
// m_pEd.StartOperation();
List <string> sInClauseList = Utils.InClauseFromOIDsList(lstLineIds, 995);
foreach (string InClause in sInClauseList)
{
m_pQF.WhereClause = pFabricLinesFC.OIDFieldName + " IN (" + InClause + ")";
if (!UpdateCircularArcValues((ITable)pFabricLinesFC, m_pQF, bIsUnVersioned, dictLineToCurveNeighbourData))
{
;
}
}
m_pEd.StopOperation("Insert missing circular arc information.");
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
m_pEd.AbortOperation();
}
finally
{
}
}
protected override void OnClick()
{
IMouseCursor pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
//first get the selected parcel features
UID pUID = new UIDClass();
pUID.Value = "{114D685F-99B7-4B63-B09F-6D1A41A4DDC1}";
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)ArcMap.Application.FindExtensionByCLSID(pUID);
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByCLSID(pUID);
//check if there is a Manual Mode "modify" job active ===========
ICadastralPacketManager pCadPacMan = (ICadastralPacketManager)pCadExtMan;
if (pCadPacMan.PacketOpen)
{
MessageBox.Show("The Delete Parcels command cannot be used when there is an open job.\r\nPlease finish or discard the open job, and try again.",
"Delete Selected Parcels");
return;
}
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
IActiveView pActiveView = ArcMap.Document.ActiveView;
IMap pMap = pActiveView.FocusMap;
ICadastralFabric pCadFabric = null;
clsFabricUtils FabricUTILS = new clsFabricUtils();
IProgressDialog2 pProgressorDialog = null;
//if we're in an edit session then grab the target fabric
if (pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
if (pCadFabric == null)
{//find the first fabric in the map
if (!FabricUTILS.GetFabricFromMap(pMap, out pCadFabric))
{
MessageBox.Show
("No Parcel Fabric found in the map.\r\nPlease add a single fabric to the map, and try again.");
return;
}
}
IArray CFParcelLayers = new ArrayClass();
if (!(FabricUTILS.GetFabricSubLayersFromFabric(pMap, pCadFabric, out CFPointLayer, out CFLineLayer,
out CFParcelLayers, out CFControlLayer, out CFLinePointLayer)))
{
return; //no fabric sublayers available for the targeted fabric
}
bool bIsFileBasedGDB = false; bool bIsUnVersioned = false; bool bUseNonVersionedDelete = false;
IWorkspace pWS = null;
ICadastralFabricLayer pCFLayer = null;
ITable pParcelsTable = null;
ITable pLinesTable = null;
ITable pLinePtsTable = null;
ITable pPointsTable = null;
ITable pControlTable = null;
try
{
//Get the selection of parcels
IFeatureLayer pFL = (IFeatureLayer)CFParcelLayers.get_Element(0);
IDataset pDS = (IDataset)pFL.FeatureClass;
pWS = pDS.Workspace;
if (!FabricUTILS.SetupEditEnvironment(pWS, pCadFabric, pEd, out bIsFileBasedGDB,
out bIsUnVersioned, out bUseNonVersionedDelete))
{
return;
}
if (bUseNonVersionedDelete)
{
pCFLayer = new CadastralFabricLayerClass();
pCFLayer.CadastralFabric = pCadFabric;
pCadEd.CadastralFabricLayer = pCFLayer;//NOTE: Need to set this back to NULL when done.
}
ICadastralSelection pCadaSel = (ICadastralSelection)pCadEd;
IEnumGSParcels pEnumGSParcels = pCadaSel.SelectedParcels;// need to get the parcels before trying to get the parcel count: BUG workaround
IFeatureSelection pFeatSel = (IFeatureSelection)pFL;
ISelectionSet2 pSelSet = (ISelectionSet2)pFeatSel.SelectionSet;
bMoreThan995UnjoinedParcels = (pSelSet.Count > pCadaSel.SelectedParcelCount); //used for bug workaround
if (pCadaSel.SelectedParcelCount == 0 && pSelSet.Count == 0)
{
MessageBox.Show("Please select some fabric parcels and try again.", "No Selection",
MessageBoxButtons.OK, MessageBoxIcon.Information);
pMouseCursor.SetCursor(0);
if (bUseNonVersionedDelete)
{
pCadEd.CadastralFabricLayer = null;
CFParcelLayers = null;
CFPointLayer = null;
CFLineLayer = null;
CFControlLayer = null;
CFLinePointLayer = null;
}
return;
}
if (bMoreThan995UnjoinedParcels)
{
m_bShowProgressor = (pSelSet.Count > 10);
}
else
{
m_bShowProgressor = (pCadaSel.SelectedParcelCount > 10);
}
if (m_bShowProgressor)
{
m_pProgressorDialogFact = new ProgressDialogFactoryClass();
m_pTrackCancel = new CancelTrackerClass();
m_pStepProgressor = m_pProgressorDialogFact.Create(m_pTrackCancel, ArcMap.Application.hWnd);
pProgressorDialog = (IProgressDialog2)m_pStepProgressor;
m_pStepProgressor.MinRange = 1;
if (bMoreThan995UnjoinedParcels)
{
m_pStepProgressor.MaxRange = pSelSet.Count * 18; //(estimate 7 lines per parcel, 4 pts per parcel, 3 line points per parcel, and there is a second loop on parcel list)
}
else
{
m_pStepProgressor.MaxRange = pCadaSel.SelectedParcelCount * 18; //(estimate 7 lines per parcel, 4 pts per parcel, 3 line points per parcel, and there is a second loop on parcel list)
}
m_pStepProgressor.StepValue = 1;
pProgressorDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressSpiral;
}
m_pQF = new QueryFilterClass();
string sPref; string sSuff;
ISQLSyntax pSQLSyntax = (ISQLSyntax)pWS;
sPref = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
sSuff = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
//====== need to do this for all the parcel sublayers in the map that are part of the target fabric
if (m_bShowProgressor)
{
pProgressorDialog.ShowDialog();
m_pStepProgressor.Message = "Collecting parcel data...";
}
//Add the OIDs of all the selected parcels into a new feature IDSet
string[] sOIDList = { "(" };
int tokenLimit = 995;
bool bCont = true;
int j = 0;
int iCounter = 0;
m_pFIDSetParcels = new FIDSetClass();
//===================== start bug workaraound for 10.0 client ===================
if (bMoreThan995UnjoinedParcels)
{
ICursor pCursor = null;
pSelSet.Search(null, false, out pCursor);//code deletes all selected parcels
IFeatureCursor pParcelFeatCurs = (IFeatureCursor)pCursor;
IFeature pParcFeat = pParcelFeatCurs.NextFeature();
while (pParcFeat != null)
{
//Check if the cancel button was pressed. If so, stop process
if (m_bShowProgressor)
{
bCont = m_pTrackCancel.Continue();
if (!bCont)
{
break;
}
}
bool bExists = false;
m_pFIDSetParcels.Find(pParcFeat.OID, out bExists);
if (!bExists)
{
m_pFIDSetParcels.Add(pParcFeat.OID);
if (iCounter <= tokenLimit)
{
sOIDList[j] = sOIDList[j] + Convert.ToString(pParcFeat.OID) + ",";
iCounter++;
}
else
{//maximum tokens reached
sOIDList[j] = sOIDList[j].Trim();
iCounter = 0;
//set up the next OIDList
j++;
FabricUTILS.RedimPreserveString(ref sOIDList, 1);
sOIDList[j] = "(";
sOIDList[j] = sOIDList[j] + Convert.ToString(pParcFeat.OID) + ",";
}
}
Marshal.ReleaseComObject(pParcFeat); //garbage collection
pParcFeat = pParcelFeatCurs.NextFeature();
if (m_bShowProgressor)
{
if (m_pStepProgressor.Position < m_pStepProgressor.MaxRange)
{
m_pStepProgressor.Step();
}
}
}
Marshal.ReleaseComObject(pCursor); //garbage collection
//===================== end bug workaraound for 10.0 client ===================
}
else //===the following code path is preferred======
{
pEnumGSParcels.Reset();
IGSParcel pGSParcel = pEnumGSParcels.Next();
while (pGSParcel != null)
{
//Check if the cancel button was pressed. If so, stop process
if (m_bShowProgressor)
{
bCont = m_pTrackCancel.Continue();
if (!bCont)
{
break;
}
}
m_pFIDSetParcels.Add(pGSParcel.DatabaseId);
if (iCounter <= tokenLimit)
{
sOIDList[j] = sOIDList[j] + Convert.ToString(pGSParcel.DatabaseId) + ",";
iCounter++;
}
else
{//maximum tokens reached
sOIDList[j] = sOIDList[j].Trim();
iCounter = 0;
//set up the next OIDList
j++;
FabricUTILS.RedimPreserveString(ref sOIDList, 1);
sOIDList[j] = "(";
sOIDList[j] = sOIDList[j] + Convert.ToString(pGSParcel.DatabaseId) + ",";
}
Marshal.ReleaseComObject(pGSParcel); //garbage collection
pGSParcel = pEnumGSParcels.Next();
if (m_bShowProgressor)
{
if (m_pStepProgressor.Position < m_pStepProgressor.MaxRange)
{
m_pStepProgressor.Step();
}
}
}
Marshal.ReleaseComObject(pEnumGSParcels); //garbage collection
}
if (!bCont)
{
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
return;
}
string sTime = "";
if (!bIsUnVersioned && !bIsFileBasedGDB)
{
//see if parcel locks can be obtained on the selected parcels. First create a job.
DateTime localNow = DateTime.Now;
sTime = Convert.ToString(localNow);
ICadastralJob pJob = new CadastralJobClass();
pJob.Name = sTime;
pJob.Owner = System.Windows.Forms.SystemInformation.UserName;
pJob.Description = "Delete selected parcels";
try
{
Int32 jobId = pCadFabric.CreateJob(pJob);
}
catch (COMException ex)
{
if (ex.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_ALREADY_EXISTS)
{
MessageBox.Show("Job named: '" + pJob.Name + "', already exists");
}
else
{
MessageBox.Show(ex.Message);
}
return;
}
}
//if we're in an enterprise then test for edit locks
ICadastralFabricLocks pFabLocks = (ICadastralFabricLocks)pCadFabric;
if (!bIsUnVersioned && !bIsFileBasedGDB)
{
pFabLocks.LockingJob = sTime;
ILongArray pLocksInConflict = null;
ILongArray pSoftLcksInConflict = null;
ILongArray pParcelsToLock = new LongArrayClass();
FabricUTILS.FIDsetToLongArray(m_pFIDSetParcels, ref pParcelsToLock, m_pStepProgressor);
if (m_bShowProgressor && !bIsFileBasedGDB)
{
m_pStepProgressor.Message = "Testing for edit locks on parcels...";
}
try
{
pFabLocks.AcquireLocks(pParcelsToLock, true, ref pLocksInConflict, ref pSoftLcksInConflict);
}
catch (COMException pCOMEx)
{
if (pCOMEx.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_LOCK_ALREADY_EXISTS ||
pCOMEx.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_CURRENTLY_EDITED)
{
MessageBox.Show("Edit Locks could not be acquired on all selected parcels.");
// since the operation is being aborted, release any locks that were acquired
pFabLocks.UndoLastAcquiredLocks();
}
else
{
MessageBox.Show(pCOMEx.Message + Environment.NewLine + Convert.ToString(pCOMEx.ErrorCode));
}
return;
}
}
//Build an IDSet of lines for the parcel to be deleted, and build an IDSet of the points for those lines
m_pFIDSetLines = new FIDSetClass();
m_pFIDSetPoints = new FIDSetClass();
if (pEd.EditState == esriEditState.esriStateEditing)
{
try
{
pEd.StartOperation();
}
catch
{
pEd.AbortOperation();//abort any open edit operations and try again
pEd.StartOperation();
}
}
if (bUseNonVersionedDelete)
{
if (!FabricUTILS.StartEditing(pWS, bIsUnVersioned))
{
return;
}
}
//first delete all the parcel records
if (m_bShowProgressor)
{
m_pStepProgressor.Message = "Deleting parcels...";
}
bool bSuccess = true;
pParcelsTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTParcels);
pLinesTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTLines);
pLinePtsTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTLinePoints);
pPointsTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTPoints);
pControlTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTControl);
if (!bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsByFIDSet(pParcelsTable, m_pFIDSetParcels, m_pStepProgressor, m_pTrackCancel);
}
if (bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsUnversioned(pWS, pParcelsTable,
m_pFIDSetParcels, m_pStepProgressor, m_pTrackCancel);
}
if (!bSuccess)
{
if (!bIsUnVersioned)
{
pFabLocks.UndoLastAcquiredLocks();
}
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
if (!bIsUnVersioned)
{
//check version and if the Cancel button was not clicked and we're higher than
//version 10.0, then re-try the delete with the core delete command
string sVersion = Application.ProductVersion;
int iErrCode = FabricUTILS.LastErrorCode;
if (!sVersion.StartsWith("10.0") && iErrCode == -2147217400)
{
FabricUTILS.ExecuteCommand("{B0A62C1C-7FAE-457A-AB25-A966B7254EF6}");
}
}
return;
}
//next need to use an in clause for lines, so ...
string[] sPointOIDList = { "" };
int iCnt = 0;
int iTokenCnt = 0;
int iStepCnt = 1;
//...for each item in the sOIDList array
foreach (string inClause in sOIDList)
{
ICursor pLineCurs = FabricUTILS.GetCursorFromCommaSeparatedOIDList(pLinesTable, inClause, "PARCELID");
IRow pRow = pLineCurs.NextRow();
Int32 iFromPt = pLinesTable.Fields.FindField("FROMPOINTID");
Int32 iToPt = pLinesTable.Fields.FindField("TOPOINTID");
while (pRow != null)
{
if (iTokenCnt >= tokenLimit)
{
FabricUTILS.RedimPreserveString(ref sPointOIDList, 1);
iTokenCnt = 0;
iCnt++;
}
m_pFIDSetLines.Add(pRow.OID);
Int32 i = (Int32)pRow.get_Value(iFromPt);
if (i > -1)
{
bool bExists = false;
m_pFIDSetPoints.Find(i, out bExists);
if (!bExists)
{
m_pFIDSetPoints.Add(i);
sPointOIDList[iCnt] = sPointOIDList[iCnt] + Convert.ToString(i) + ",";
iTokenCnt++;
}
}
i = (Int32)pRow.get_Value(iToPt);
if (i > -1)
{
bool bExists = false;
m_pFIDSetPoints.Find(i, out bExists);
if (!bExists)
{
m_pFIDSetPoints.Add(i);
sPointOIDList[iCnt] = sPointOIDList[iCnt] + Convert.ToString(i) + ",";
iTokenCnt++;
}
}
Marshal.ReleaseComObject(pRow); //garbage collection
pRow = pLineCurs.NextRow();
}
Marshal.ReleaseComObject(pLineCurs); //garbage collection
//delete line records based on the selected parcels
string sMessage = "Deleting lines...";
int iSetCnt = sOIDList.GetLength(0);
if (iSetCnt > 1)
{
sMessage += "Step " + Convert.ToString(iStepCnt) + " of " + Convert.ToString(iSetCnt);
}
if (m_bShowProgressor)
{
m_pStepProgressor.Message = sMessage;
}
if (!bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsByFIDSet(pLinesTable, m_pFIDSetLines, m_pStepProgressor, m_pTrackCancel);
}
if (bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsUnversioned(pWS, pLinesTable, m_pFIDSetLines, m_pStepProgressor, m_pTrackCancel);
}
if (!bSuccess)
{
if (!bIsUnVersioned)
{
pFabLocks.UndoLastAcquiredLocks();
}
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
return;
}
//delete the line points for the deleted parcels
//build the list of the line points that need to be deleted.
//IFeatureClass pFeatCLLinePoints = CFLinePointLayer.FeatureClass;
string NewInClause = "";
//remove trailing comma
if ((inClause.Substring(inClause.Length - 1, 1)) == ",")
{
NewInClause = inClause.Substring(0, inClause.Length - 1);
}
//m_pQF.WhereClause = (sPref + "parcelid" + sSuff).Trim() + " IN " + NewInClause + ")";
m_pQF.WhereClause = "PARCELID IN " + NewInClause + ")";
ICursor pLinePointCurs = pLinePtsTable.Search(m_pQF, false);
IRow pLinePointFeat = pLinePointCurs.NextRow();
//Build an IDSet of linepoints for parcels to be deleted
IFIDSet pFIDSetLinePoints = new FIDSetClass();
while (pLinePointFeat != null)
{
pFIDSetLinePoints.Add(pLinePointFeat.OID);
Marshal.ReleaseComObject(pLinePointFeat); //garbage collection
pLinePointFeat = pLinePointCurs.NextRow();
}
//===========deletes linepoints associated with parcels
iSetCnt = sOIDList.GetLength(0);
sMessage = "Deleting line-points...";
if (iSetCnt > 1)
{
sMessage += "Step " + Convert.ToString(iStepCnt) + " of " + Convert.ToString(iSetCnt);
}
if (m_bShowProgressor)
{
m_pStepProgressor.Message = sMessage;
}
if (!bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsByFIDSet(pLinePtsTable,
pFIDSetLinePoints, m_pStepProgressor, m_pTrackCancel);
}
if (bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsUnversioned(pWS, pLinePtsTable,
pFIDSetLinePoints, m_pStepProgressor, m_pTrackCancel);
}
if (!bSuccess)
{
if (!bIsUnVersioned)
{
pFabLocks.UndoLastAcquiredLocks();
}
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
if (pLinePointCurs != null)
{
Marshal.ReleaseComObject(pLinePointCurs); //garbage
}
return;
}
///////==============================================
Marshal.ReleaseComObject(pLinePointCurs); //garbage
iStepCnt++;
}
//now need to get points that should not be deleted, because they are used by lines that are not deleted.
//first search for the remaining lines. Any that have from/to points that are in the point fidset are the points
//that should stay
IFIDSet pFIDSetNullGeomLinePtFrom = new FIDSetClass();
IFIDSet pFIDSetNullGeomLinePtTo = new FIDSetClass();
if (m_bShowProgressor)
{
m_pStepProgressor.Message = "Updating point delete list...";
}
for (int z = 0; z <= iCnt; z++)
{
//remove trailing comma
if ((sPointOIDList[z].Trim() == ""))
{
break;
}
if ((sPointOIDList[z].Substring(sPointOIDList[z].Length - 1, 1)) == ",")
{
sPointOIDList[z] = sPointOIDList[z].Substring(0, sPointOIDList[z].Length - 1);
}
}
//string TheWhereClause = "(" + (sPref + "frompointid" + sSuff).Trim() + " IN (";
//UpdateDeletePointList(ref sPointOIDList, ref m_pFIDSetPoints, "frompointid",
// TheWhereClause, pLinesTable, out pFIDSetNullGeomLinePtFrom);
//TheWhereClause = "(" + (sPref + "topointid" + sSuff).Trim() + " IN (";
//UpdateDeletePointList(ref sPointOIDList, ref m_pFIDSetPoints, "topointid",
// TheWhereClause, pLinesTable, out pFIDSetNullGeomLinePtTo);
string TheWhereClause = "(FROMPOINTID IN (";
UpdateDeletePointList(ref sPointOIDList, ref m_pFIDSetPoints, "FROMPOINTID",
TheWhereClause, pLinesTable, out pFIDSetNullGeomLinePtFrom);
TheWhereClause = "(TOPOINTID IN (";
UpdateDeletePointList(ref sPointOIDList, ref m_pFIDSetPoints, "TOPOINTID",
TheWhereClause, pLinesTable, out pFIDSetNullGeomLinePtTo);
if (m_bShowProgressor)
{
m_pStepProgressor.Message = "Deleting points...";
}
if (!bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsByFIDSet(pPointsTable, m_pFIDSetPoints,
m_pStepProgressor, m_pTrackCancel);
}
if (bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsUnversioned(pWS, pPointsTable, m_pFIDSetPoints,
m_pStepProgressor, m_pTrackCancel);
}
if (!bSuccess)
{
if (!bIsUnVersioned)
{
pFabLocks.UndoLastAcquiredLocks();
}
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
return;
}
//====Phase 2 of line-point delete. Remove the Line-points that no longer have underlying points.
if (m_bShowProgressor)
{
m_pStepProgressor.Message = "Deleting line-points...";
}
for (int z = 0; z <= iCnt; z++)
{
if ((sPointOIDList[z].Trim() == ""))
{
continue;
}
//remove line points where underlying points were deleted
bSuccess = FabricUTILS.DeleteByQuery(pWS, pLinePtsTable, pLinePtsTable.Fields.get_Field(pLinePtsTable.FindField("LinePointID")),
sPointOIDList, !bIsUnVersioned, m_pStepProgressor, m_pTrackCancel);
if (!bSuccess)
{
if (!bIsUnVersioned)
{
pFabLocks.UndoLastAcquiredLocks();
}
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
return;
}
}
//=====
//Empty geometry on points that are floating points on unjoined parcels
m_pEmptyGeoms = new FIDSetClass();
FabricUTILS.IntersectFIDSetCommonIDs(pFIDSetNullGeomLinePtTo, pFIDSetNullGeomLinePtFrom, out m_pEmptyGeoms);
ICadastralFabricSchemaEdit2 pSchemaEd = (ICadastralFabricSchemaEdit2)pCadFabric;
pSchemaEd.ReleaseReadOnlyFields(pPointsTable, esriCadastralFabricTable.esriCFTPoints); //release safety-catch
if (!bUseNonVersionedDelete)
{
FabricUTILS.EmptyGeometries((IFeatureClass)pPointsTable, m_pEmptyGeoms);
}
else
{
FabricUTILS.EmptyGeometriesUnversioned(pWS, CFPointLayer.FeatureClass, m_pEmptyGeoms);
}
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTPoints);//set safety back on
if (m_bShowProgressor)
{
m_pStepProgressor.Message = "Resetting control point associations...";
}
for (int z = 0; z <= iCnt; z++)
{
if ((sPointOIDList[z].Trim() == ""))
{
break;
}
//cleanup associated control points, and associations where underlying points were deleted
//m_pQF.WhereClause = (sPref + "pointid" + sSuff).Trim() + " IN (" + sPointOIDList[z] + ")";
m_pQF.WhereClause = "POINTID IN (" + sPointOIDList[z] + ")";
pSchemaEd.ReleaseReadOnlyFields(pControlTable, esriCadastralFabricTable.esriCFTControl); //release safety-catch
if (!FabricUTILS.ResetControlAssociations(pControlTable, m_pQF, bUseNonVersionedDelete))
{
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTControl);//set safety back on
}
}
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTControl);//set safety back on
if (bUseNonVersionedDelete)
{
FabricUTILS.StopEditing(pWS);
}
if (pEd.EditState == esriEditState.esriStateEditing)
{
pEd.StopOperation("Delete parcels");
}
//clear selection, to make sure the parcel explorer is updated and refreshed properly
if (pFeatSel != null && bMoreThan995UnjoinedParcels)
{
pFeatSel.Clear();
}
}
catch (Exception ex)
{
if (bUseNonVersionedDelete)
{
FabricUTILS.AbortEditing(pWS);
}
if (pEd != null)
{
if (pEd.EditState == esriEditState.esriStateEditing)
{
pEd.AbortOperation();
}
}
MessageBox.Show(ex.Message);
return;
}
finally
{
RefreshMap(pActiveView, CFParcelLayers, CFPointLayer, CFLineLayer, CFControlLayer, CFLinePointLayer);
//update the TOC
IMxDocument mxDocument = (ESRI.ArcGIS.ArcMapUI.IMxDocument)(ArcMap.Application.Document);
for (int i = 0; i < mxDocument.ContentsViewCount; i++)
{
IContentsView pCV = (IContentsView)mxDocument.get_ContentsView(i);
pCV.Refresh(null);
}
if (pMouseCursor != null)
{
pMouseCursor.SetCursor(0);
}
m_pStepProgressor = null;
if (!(pProgressorDialog == null))
{
pProgressorDialog.HideDialog();
}
pProgressorDialog = null;
if (bUseNonVersionedDelete)
{
pCadEd.CadastralFabricLayer = null;
CFParcelLayers = null;
CFPointLayer = null;
CFLineLayer = null;
CFControlLayer = null;
CFLinePointLayer = null;
}
}
}
protected override void OnClick()
{
bool bShowProgressor = false;
IStepProgressor pStepProgressor = null;
//Create a CancelTracker.
ITrackCancel pTrackCancel = null;
IProgressDialogFactory pProgressorDialogFact;
IMouseCursor pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
//first get the selected parcel features
UID pUID = new UIDClass();
pUID.Value = "{114D685F-99B7-4B63-B09F-6D1A41A4DDC1}";
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)ArcMap.Application.FindExtensionByCLSID(pUID);
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByCLSID(pUID);
//check if there is a Manual Mode "modify" job active ===========
ICadastralPacketManager pCadPacMan = (ICadastralPacketManager)pCadExtMan;
if (pCadPacMan.PacketOpen)
{
MessageBox.Show("The Delete linepoint command cannot be used when there is an open job.\r\nPlease finish or discard the open job, and try again.",
"Delete Selected LinePoints");
return;
}
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
IActiveView pActiveView = ArcMap.Document.ActiveView;
IMap pMap = pActiveView.FocusMap;
ICadastralFabric pCadFabric = null;
clsFabricUtils FabricUTILS = new clsFabricUtils();
IProgressDialog2 pProgressorDialog = null;
//if we're in an edit session then grab the target fabric
if (pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
if (pCadFabric == null)
{//find the first fabric in the map
if (!FabricUTILS.GetFabricFromMap(pMap, out pCadFabric))
{
MessageBox.Show
("No Parcel Fabric found in the map.\r\nPlease add a single fabric to the map, and try again.");
return;
}
}
IArray CFLinePointLayers = new ArrayClass();
if (!(FabricUTILS.GetLinePointLayersFromFabric(pMap, pCadFabric, out CFLinePointLayers)))
{
return; //no fabric sublayers available for the targeted fabric
}
bool bIsFileBasedGDB = false; bool bIsUnVersioned = false; bool bUseNonVersionedDelete = false;
IWorkspace pWS = null;
ITable pLinePointTable = null;
try
{
if (pEd.EditState == esriEditState.esriStateEditing)
{
try
{
pEd.StartOperation();
}
catch
{
pEd.AbortOperation();//abort any open edit operations and try again
pEd.StartOperation();
}
}
IFeatureLayer pFL = (IFeatureLayer)CFLinePointLayers.get_Element(0);
IDataset pDS = (IDataset)pFL.FeatureClass;
pWS = pDS.Workspace;
if (!FabricUTILS.SetupEditEnvironment(pWS, pCadFabric, pEd, out bIsFileBasedGDB,
out bIsUnVersioned, out bUseNonVersionedDelete))
{
return;
}
//loop through each linepoint layer and
//Get the selection of linepoints
int iCnt = 0;
int iTotalSelectionCount = 0;
for (; iCnt < CFLinePointLayers.Count; iCnt++)
{
pFL = (IFeatureLayer)CFLinePointLayers.get_Element(iCnt);
IFeatureSelection pFeatSel = (IFeatureSelection)pFL;
ISelectionSet2 pSelSet = (ISelectionSet2)pFeatSel.SelectionSet;
iTotalSelectionCount += pSelSet.Count;
}
if (iTotalSelectionCount == 0)
{
MessageBox.Show("Please select some line points and try again.", "No Selection",
MessageBoxButtons.OK, MessageBoxIcon.Information);
if (bUseNonVersionedDelete)
{
pCadEd.CadastralFabricLayer = null;
CFLinePointLayers = null;
}
return;
}
bShowProgressor = (iTotalSelectionCount > 10);
if (bShowProgressor)
{
pProgressorDialogFact = new ProgressDialogFactoryClass();
pTrackCancel = new CancelTrackerClass();
pStepProgressor = pProgressorDialogFact.Create(pTrackCancel, ArcMap.Application.hWnd);
pProgressorDialog = (IProgressDialog2)pStepProgressor;
pStepProgressor.MinRange = 1;
pStepProgressor.MaxRange = iTotalSelectionCount;
pStepProgressor.StepValue = 1;
pProgressorDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressSpiral;
}
//loop through each linepoint layer and
//delete from its selection
m_pQF = new QueryFilterClass();
iCnt = 0;
for (; iCnt < CFLinePointLayers.Count; iCnt++)
{
pFL = (IFeatureLayer)CFLinePointLayers.get_Element(iCnt);
IFeatureSelection pFeatSel = (IFeatureSelection)pFL;
ISelectionSet2 pSelSet = (ISelectionSet2)pFeatSel.SelectionSet;
ISQLSyntax pSQLSyntax = (ISQLSyntax)pWS;
string sPref = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
string sSuff = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
if (bShowProgressor)
{
pProgressorDialog.ShowDialog();
pStepProgressor.Message = "Collecting line point data...";
}
//Add the OIDs of all the selected linepoints into a new feature IDSet
bool bCont = true;
m_pFIDSetLinePoints = new FIDSetClass();
ICursor pCursor = null;
pSelSet.Search(null, false, out pCursor);//code deletes all selected line points
IFeatureCursor pLinePointFeatCurs = (IFeatureCursor)pCursor;
IFeature pLinePointFeat = pLinePointFeatCurs.NextFeature();
while (pLinePointFeat != null)
{
//Check if the cancel button was pressed. If so, stop process
if (bShowProgressor)
{
bCont = pTrackCancel.Continue();
if (!bCont)
{
break;
}
}
bool bExists = false;
m_pFIDSetLinePoints.Find(pLinePointFeat.OID, out bExists);
if (!bExists)
{
m_pFIDSetLinePoints.Add(pLinePointFeat.OID);
}
Marshal.ReleaseComObject(pLinePointFeat); //garbage collection
pLinePointFeat = pLinePointFeatCurs.NextFeature();
if (bShowProgressor)
{
if (pStepProgressor.Position < pStepProgressor.MaxRange)
{
pStepProgressor.Step();
}
}
}
Marshal.ReleaseComObject(pCursor); //garbage collection
if (!bCont)
{
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
return;
}
if (bUseNonVersionedDelete)
{
if (!FabricUTILS.StartEditing(pWS, bIsUnVersioned))
{
if (bUseNonVersionedDelete)
{
pCadEd.CadastralFabricLayer = null;
}
return;
}
}
//delete all the line point records
if (bShowProgressor)
{
pStepProgressor.Message = "Deleting selected line points...";
}
bool bSuccess = true;
pLinePointTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTLinePoints);
if (!bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsByFIDSet(pLinePointTable, m_pFIDSetLinePoints, pStepProgressor, pTrackCancel);
}
if (bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsUnversioned(pWS, pLinePointTable,
m_pFIDSetLinePoints, pStepProgressor, pTrackCancel);
}
if (!bSuccess)
{
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
return;
}
}
if (bUseNonVersionedDelete)
{
FabricUTILS.StopEditing(pWS);
}
if (pEd.EditState == esriEditState.esriStateEditing)
{
pEd.StopOperation("Delete Line Points");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
finally
{
RefreshMap(pActiveView, CFLinePointLayers);
//update the TOC
IMxDocument mxDocument = (ESRI.ArcGIS.ArcMapUI.IMxDocument)(ArcMap.Application.Document);
for (int i = 0; i < mxDocument.ContentsViewCount; i++)
{
IContentsView pCV = (IContentsView)mxDocument.get_ContentsView(i);
pCV.Refresh(null);
}
if (pProgressorDialog != null)
{
pProgressorDialog.HideDialog();
}
if (bUseNonVersionedDelete)
{
pCadEd.CadastralFabricLayer = null;
CFLinePointLayers = null;
}
if (pMouseCursor != null)
{
pMouseCursor.SetCursor(0);
}
}
}
protected override void OnClick()
{
IMouseCursor pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
//first get the selected parcel features
UID pUID = new UIDClass();
pUID.Value = "{114D685F-99B7-4B63-B09F-6D1A41A4DDC1}";
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)ArcMap.Application.FindExtensionByCLSID(pUID);
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByCLSID(pUID);
Marshal.ReleaseComObject(pUID);
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
IFeatureLayer CFPointLayer = null; IFeatureLayer CFLineLayer = null;
IFeatureLayer CFControlLayer = null;
IFeatureLayer CFLinePointLayer = null;
IActiveView pActiveView = ArcMap.Document.ActiveView;
IMap pMap = pActiveView.FocusMap;
ICadastralFabric pCadFabric = null;
IProgressDialog2 pProgressorDialog = null;
clsFabricUtils UTILS = new clsFabricUtils();
//if we're in an edit session then grab the target fabric
if (pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
if (pCadFabric == null)
{//find the first fabric in the map
if (!UTILS.GetFabricFromMap(pMap, out pCadFabric))
{
MessageBox.Show
("No Parcel Fabric found in the map.\r\nPlease add a single fabric to the map, and try again.");
return;
}
}
IArray CFParcelLayers = new ArrayClass();
if (!(UTILS.GetFabricSubLayersFromFabric(pMap, pCadFabric, out CFPointLayer, out CFLineLayer,
out CFParcelLayers, out CFControlLayer, out CFLinePointLayer)))
{
return; //no fabric sublayers available for the targeted fabric
}
bool bIsFileBasedGDB = false; bool bIsUnVersioned = false; bool bUseNonVersioned = false;
IWorkspace pWS = null;
try
{
//Get the selection of parcels
IFeatureLayer pFL = (IFeatureLayer)CFParcelLayers.get_Element(0);
IDataset pDS = (IDataset)pFL.FeatureClass;
pWS = pDS.Workspace;
if (!UTILS.SetupEditEnvironment(pWS, pCadFabric, pEd, out bIsFileBasedGDB,
out bIsUnVersioned, out bUseNonVersioned))
{
return;
}
if (bUseNonVersioned)
{
ICadastralFabricLayer pCFLayer = new CadastralFabricLayerClass();
pCFLayer.CadastralFabric = pCadFabric;
pCadEd.CadastralFabricLayer = pCFLayer;//NOTE: Need to set this back to NULL when done.
}
Hashtable FabLyrToFieldMap = new Hashtable();
DateChanger pDateChangerDialog = new DateChanger();
pDateChangerDialog.cboBoxFabricClasses.Items.Clear();
string[] FieldStrArr = new string[CFParcelLayers.Count];
for (int i = 0; i < CFParcelLayers.Count; i++)
{
FieldStrArr[i] = "";
IFeatureLayer lyr = (IFeatureLayer)CFParcelLayers.get_Element(i);
// ICadastralFabricLayer cflyr = CFParcelLayers.get_Element(i);
pDateChangerDialog.cboBoxFabricClasses.Items.Add(lyr.Name);
IFields pFlds = lyr.FeatureClass.Fields;
for (int j = 0; j < lyr.FeatureClass.Fields.FieldCount; j++)
{
IField pFld = lyr.FeatureClass.Fields.get_Field(j);
if (pFld.Type == esriFieldType.esriFieldTypeDate)
{
if (FieldStrArr[i].Trim() == "")
{
FieldStrArr[i] = pFld.Name;
}
else
{
FieldStrArr[i] += "," + pFld.Name;
}
}
}
FabLyrToFieldMap.Add(i, FieldStrArr[i]);
}
pDateChangerDialog.FieldMap = FabLyrToFieldMap;
pDateChangerDialog.cboBoxFabricClasses.SelectedIndex = 0;
// ******** Display the dialog *********
DialogResult pDialogResult = pDateChangerDialog.ShowDialog();
if (pDialogResult != DialogResult.OK)
{
return;
}
//************************
//*** get the choices from the dialog
IFeatureLayer flyr = (IFeatureLayer)CFParcelLayers.get_Element(pDateChangerDialog.cboBoxFabricClasses.SelectedIndex);
int iDateFld = flyr.FeatureClass.Fields.FindField(pDateChangerDialog.cboBoxFields.Text);
if (pDateChangerDialog.radioButton2.Checked)
{
IField pFld = flyr.FeatureClass.Fields.get_Field(iDateFld);
if (!pFld.IsNullable)
{
MessageBox.Show("The field you selected does not allow NULL values, and must have a date." + Environment.NewLine +
"Please try again using the date option, or using a different date field.", "Field does not Allow Null", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
}
ICadastralFabricSubLayer pSubLyr = (ICadastralFabricSubLayer)flyr;
bool bLines = false;
bool bParcels = false;
if (pSubLyr.CadastralTableType == esriCadastralFabricTable.esriCFTLines)
{
bLines = true;
}
if (pSubLyr.CadastralTableType == esriCadastralFabricTable.esriCFTParcels)
{
bParcels = true;
}
//find out if there is a selection for the chosen layer
bool ChosenLayerHasSelection = false;
IFeatureSelection pFeatSel = null;
ISelectionSet2 pSelSet = null;
ICadastralSelection pCadaSel = null;
IEnumGSParcels pEnumGSParcels = null;
int iFeatureCnt = 0;
pFeatSel = (IFeatureSelection)flyr;
if (pFeatSel != null)
{
pSelSet = (ISelectionSet2)pFeatSel.SelectionSet;
ChosenLayerHasSelection = (pSelSet.Count > 0);
iFeatureCnt = pSelSet.Count;
}
//****
if (iFeatureCnt == 0)
{
if (MessageBox.Show("There are no features selected in the " + flyr.Name + " layer." + Environment.NewLine + "Click OK to Change dates for ALL features in the layer.", "No Selection",
MessageBoxButtons.OKCancel) != DialogResult.OK)
{
return;
}
}
else
{
pCadaSel = (ICadastralSelection)pCadEd;
//** TODO: this enum should be based on the selected points, lines, or line-points
pEnumGSParcels = pCadaSel.SelectedParcels;// need to get the parcels before trying to get the parcel count: BUG workaround
//***
}
if (iFeatureCnt == 0)
{
m_pCursor = (ICursor)flyr.FeatureClass.Search(null, false);
ITable pTable = (ITable)flyr.FeatureClass;
iFeatureCnt = pTable.RowCount(null);
}
m_bShowProgressor = (iFeatureCnt > 10);
if (m_bShowProgressor)
{
m_pProgressorDialogFact = new ProgressDialogFactoryClass();
m_pTrackCancel = new CancelTrackerClass();
m_pStepProgressor = m_pProgressorDialogFact.Create(m_pTrackCancel, ArcMap.Application.hWnd);
pProgressorDialog = (IProgressDialog2)m_pStepProgressor;
m_pStepProgressor.MinRange = 1;
m_pStepProgressor.MaxRange = iFeatureCnt;
m_pStepProgressor.StepValue = 1;
pProgressorDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressSpiral;
}
m_pQF = new QueryFilterClass();
string sPref; string sSuff;
ISQLSyntax pSQLSyntax = (ISQLSyntax)pWS;
sPref = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
sSuff = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
//====== need to do this for all the parcel sublayers in the map that are part of the target fabric
if (m_bShowProgressor)
{
pProgressorDialog.ShowDialog();
m_pStepProgressor.Message = "Collecting data...";
}
bool bCont = true;
m_pFIDSetParcels = new FIDSetClass();
if (ChosenLayerHasSelection && bParcels && !bIsUnVersioned)
{
//if there is a selection add the OIDs of all the selected parcels into a new feature IDSet
pEnumGSParcels.Reset();
IGSParcel pGSParcel = pEnumGSParcels.Next();
while (pGSParcel != null)
{
//Check if the cancel button was pressed. If so, stop process
if (m_bShowProgressor)
{
bCont = m_pTrackCancel.Continue();
if (!bCont)
{
break;
}
}
m_pFIDSetParcels.Add(pGSParcel.DatabaseId);
Marshal.ReleaseComObject(pGSParcel); //garbage collection
pGSParcel = pEnumGSParcels.Next();
//}
if (m_bShowProgressor)
{
if (m_pStepProgressor.Position < m_pStepProgressor.MaxRange)
{
m_pStepProgressor.Step();
}
}
}
}
if ((!ChosenLayerHasSelection && bParcels && !bIsUnVersioned) ||
(!ChosenLayerHasSelection && bLines && !bIsUnVersioned))
{
IRow pRow = m_pCursor.NextRow();
while (pRow != null)
{
m_pFIDSetParcels.Add(pRow.OID);
Marshal.ReleaseComObject(pRow);
pRow = m_pCursor.NextRow();
}
Marshal.ReleaseComObject(m_pCursor);
}
if (bLines && ChosenLayerHasSelection && !bIsUnVersioned)
{
pSelSet.Search(null, false, out m_pCursor);
IRow pRow = m_pCursor.NextRow();
int iFld = m_pCursor.FindField("PARCELID");
while (pRow != null)
{
m_pFIDSetParcels.Add((int)pRow.get_Value(iFld));
Marshal.ReleaseComObject(pRow);
pRow = m_pCursor.NextRow();
}
Marshal.ReleaseComObject(m_pCursor);
}
//=========================================================
if (!bCont)
{
//Since I'm using update cursor need to clear the cadastral selection
pCadaSel.SelectedParcels = null;
//clear selection, to make sure the parcel explorer is updated and refreshed properly
return;
}
string sTime = "";
if (!bIsUnVersioned)
{
//see if parcel locks can be obtained on the selected parcels. First create a job.
DateTime localNow = DateTime.Now;
sTime = Convert.ToString(localNow);
ICadastralJob pJob = new CadastralJobClass();
pJob.Name = sTime;
pJob.Owner = System.Windows.Forms.SystemInformation.UserName;
pJob.Description = "Change Date on selected parcels";
try
{
Int32 jobId = pCadFabric.CreateJob(pJob);
}
catch (COMException ex)
{
if (ex.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_ALREADY_EXISTS)
{
MessageBox.Show("Job named: '" + pJob.Name + "', already exists");
}
else
{
MessageBox.Show(ex.Message);
}
m_pStepProgressor = null;
if (!(pProgressorDialog == null))
{
pProgressorDialog.HideDialog();
}
pProgressorDialog = null;
if (bUseNonVersioned)
{
pCadEd.CadastralFabricLayer = null;
}
return;
}
}
//if we're in an enterprise then test for edit locks
ICadastralFabricLocks pFabLocks = (ICadastralFabricLocks)pCadFabric;
if (!bIsUnVersioned)
{
pFabLocks.LockingJob = sTime;
ILongArray pLocksInConflict = null;
ILongArray pSoftLcksInConflict = null;
ILongArray pParcelsToLock = new LongArrayClass();
UTILS.FIDsetToLongArray(m_pFIDSetParcels, ref pParcelsToLock, m_pStepProgressor);
if (m_pStepProgressor != null && !bIsFileBasedGDB)
{
m_pStepProgressor.Message = "Testing for edit locks on parcels...";
}
try
{
pFabLocks.AcquireLocks(pParcelsToLock, true, ref pLocksInConflict, ref pSoftLcksInConflict);
}
catch (COMException pCOMEx)
{
if (pCOMEx.ErrorCode == (int)fdoError.FDO_E_CADASTRAL_FABRIC_JOB_LOCK_ALREADY_EXISTS)
{
MessageBox.Show("Edit Locks could not be acquired on all selected parcels.");
// since the operation is being aborted, release any locks that were acquired
pFabLocks.UndoLastAcquiredLocks();
//clear selection, to make sure the parcel explorer is updated and refreshed properly
RefreshMap(pActiveView, CFParcelLayers, CFPointLayer, CFLineLayer, CFControlLayer, CFLinePointLayer);
}
else
{
MessageBox.Show(Convert.ToString(pCOMEx.ErrorCode));
}
if (bUseNonVersioned)
{
pCadEd.CadastralFabricLayer = null;
}
return;
}
}
//Now... start the edit. Start an edit operation.
if (pEd.EditState == esriEditState.esriStateEditing)
{
pEd.StartOperation();
}
if (bUseNonVersioned)
{
if (!UTILS.StartEditing(pWS, bUseNonVersioned))
{
if (bUseNonVersioned)
{
pCadEd.CadastralFabricLayer = null;
}
return;
}
}
//Change all the date records
if (m_pStepProgressor != null)
{
m_pStepProgressor.Message = "Changing dates...";
}
bool bSuccess = true;
ITable Table2Edit = (ITable)flyr.FeatureClass;
ITableWrite pTableWr = (ITableWrite)Table2Edit;
if (ChosenLayerHasSelection)
{
//TODO: Selection based update does not work on unversioned tables
//need to change this code to create an update cursor from the selection,
//including code for tokens > 995
pSelSet.Update(null, false, out m_pCursor);
}
else
{
if (bUseNonVersioned)
{
m_pCursor = pTableWr.UpdateRows(null, false);
}
else
{
m_pCursor = Table2Edit.Update(null, false);
}
}
ICadastralFabricSchemaEdit2 pSchemaEd = (ICadastralFabricSchemaEdit2)pCadFabric;
if (bLines)
{
pSchemaEd.ReleaseReadOnlyFields(Table2Edit,
esriCadastralFabricTable.esriCFTLines); //release safety-catch
}
else if (bParcels)
{
pSchemaEd.ReleaseReadOnlyFields(Table2Edit,
esriCadastralFabricTable.esriCFTParcels); //release safety-catch
}
else
{
pSchemaEd.ReleaseReadOnlyFields(Table2Edit,
esriCadastralFabricTable.esriCFTPoints); //release safety-catch
pSchemaEd.ReleaseReadOnlyFields(Table2Edit,
esriCadastralFabricTable.esriCFTControl); //release safety-catch
pSchemaEd.ReleaseReadOnlyFields(Table2Edit,
esriCadastralFabricTable.esriCFTLinePoints); //release safety-catch
}
if (pDateChangerDialog.radioButton2.Checked)
{
bSuccess = UTILS.ChangeDatesOnTable(m_pCursor, pDateChangerDialog.cboBoxFields.Text, "",
bUseNonVersioned, m_pStepProgressor, m_pTrackCancel);
}
else
{
bSuccess = UTILS.ChangeDatesOnTable(m_pCursor, pDateChangerDialog.cboBoxFields.Text,
pDateChangerDialog.dateTimePicker1.Text, bUseNonVersioned, m_pStepProgressor, m_pTrackCancel);
}
if (!bSuccess)
{
if (!bIsUnVersioned)
{
pFabLocks.UndoLastAcquiredLocks();
}
if (bUseNonVersioned)
{
UTILS.AbortEditing(pWS);
}
else
{
pEd.AbortOperation();
}
//clear selection, to make sure the parcel explorer is updated and refreshed properly
return;
}
if (pEd.EditState == esriEditState.esriStateEditing)
{
pEd.StopOperation("Change Date");
}
if (bUseNonVersioned)
{
UTILS.StopEditing(pWS);
}
if (bParcels)
{
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTParcels);
}
else if (bLines)
{
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTLines);
}
else
{
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTPoints); //release safety-catch
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTControl); //release safety-catch
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTLinePoints); //release safety-catch
}
}
catch (Exception ex)
{
MessageBox.Show("Error:" + ex.Message);
if (bUseNonVersioned)
{
UTILS.AbortEditing(pWS);
}
else
{
pEd.AbortOperation();
}
}
finally
{
RefreshMap(pActiveView, CFParcelLayers, CFPointLayer, CFLineLayer, CFControlLayer, CFLinePointLayer);
if (bUseNonVersioned)
{
pCadEd.CadastralFabricLayer = null;
CFParcelLayers = null;
CFPointLayer = null;
CFLineLayer = null;
CFControlLayer = null;
CFLinePointLayer = null;
}
m_pStepProgressor = null;
if (!(pProgressorDialog == null))
{
pProgressorDialog.HideDialog();
}
pProgressorDialog = null;
}
}
protected override void OnClick()
{
bool bShowProgressor = false;
IStepProgressor pStepProgressor = null;
//Create a CancelTracker.
ITrackCancel pTrackCancel = null;
IProgressDialogFactory pProgressorDialogFact;
IMouseCursor pMouseCursor = new MouseCursorClass();
pMouseCursor.SetCursor(2);
//first get the selected parcel features
UID pUID = new UIDClass();
pUID.Value = "{114D685F-99B7-4B63-B09F-6D1A41A4DDC1}";
ICadastralExtensionManager2 pCadExtMan = (ICadastralExtensionManager2)ArcMap.Application.FindExtensionByCLSID(pUID);
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByCLSID(pUID);
//check if there is a Manual Mode "modify" job active ===========
ICadastralPacketManager pCadPacMan = (ICadastralPacketManager)pCadExtMan;
if (pCadPacMan.PacketOpen)
{
MessageBox.Show("The Delete Control command cannot be used when there is an open job.\r\nPlease finish or discard the open job, and try again.",
"Delete Selected Control");
return;
}
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
IActiveView pActiveView = ArcMap.Document.ActiveView;
IMap pMap = pActiveView.FocusMap;
ICadastralFabric pCadFabric = null;
clsFabricUtils FabricUTILS = new clsFabricUtils();
IProgressDialog2 pProgressorDialog = null;
//if we're in an edit session then grab the target fabric
if (pEd.EditState == esriEditState.esriStateEditing)
{
pCadFabric = pCadEd.CadastralFabric;
}
if (pCadFabric == null)
{//find the first fabric in the map
if (!FabricUTILS.GetFabricFromMap(pMap, out pCadFabric))
{
MessageBox.Show
("No Parcel Fabric found in the map.\r\nPlease add a single fabric to the map, and try again.");
return;
}
}
IArray CFControlLayers = new ArrayClass();
if (!(FabricUTILS.GetControlLayersFromFabric(pMap, pCadFabric, out CFControlLayers)))
{
return; //no fabric sublayers available for the targeted fabric
}
bool bIsFileBasedGDB = false; bool bIsUnVersioned = false; bool bUseNonVersionedDelete = false;
IWorkspace pWS = null;
ITable pPointsTable = null;
ITable pControlTable = null;
try
{
if (pEd.EditState == esriEditState.esriStateEditing)
{
try
{
pEd.StartOperation();
}
catch
{
pEd.AbortOperation();//abort any open edit operations and try again
pEd.StartOperation();
}
}
IFeatureLayer pFL = (IFeatureLayer)CFControlLayers.get_Element(0);
IDataset pDS = (IDataset)pFL.FeatureClass;
pWS = pDS.Workspace;
if (!FabricUTILS.SetupEditEnvironment(pWS, pCadFabric, pEd, out bIsFileBasedGDB,
out bIsUnVersioned, out bUseNonVersionedDelete))
{
return;
}
//loop through each control layer and
//Get the selection of control
int iCnt = 0;
int iTotalSelectionCount = 0;
for (; iCnt < CFControlLayers.Count; iCnt++)
{
pFL = (IFeatureLayer)CFControlLayers.get_Element(iCnt);
IFeatureSelection pFeatSel = (IFeatureSelection)pFL;
ISelectionSet2 pSelSet = (ISelectionSet2)pFeatSel.SelectionSet;
iTotalSelectionCount += pSelSet.Count;
}
if (iTotalSelectionCount == 0)
{
MessageBox.Show("Please select some fabric control points and try again.", "No Selection",
MessageBoxButtons.OK, MessageBoxIcon.Information);
if (bUseNonVersionedDelete)
{
pCadEd.CadastralFabricLayer = null;
CFControlLayers = null;
}
return;
}
bShowProgressor = (iTotalSelectionCount > 10);
if (bShowProgressor)
{
pProgressorDialogFact = new ProgressDialogFactoryClass();
pTrackCancel = new CancelTrackerClass();
pStepProgressor = pProgressorDialogFact.Create(pTrackCancel, ArcMap.Application.hWnd);
pProgressorDialog = (IProgressDialog2)pStepProgressor;
pStepProgressor.MinRange = 1;
pStepProgressor.MaxRange = iTotalSelectionCount * 2; //(runs through selection twice)
pStepProgressor.StepValue = 1;
pProgressorDialog.Animation = ESRI.ArcGIS.Framework.esriProgressAnimationTypes.esriProgressSpiral;
}
//loop through each control layer and
//delete from its selection
m_pQF = new QueryFilterClass();
iCnt = 0;
for (; iCnt < CFControlLayers.Count; iCnt++)
{
pFL = (IFeatureLayer)CFControlLayers.get_Element(iCnt);
IFeatureSelection pFeatSel = (IFeatureSelection)pFL;
ISelectionSet2 pSelSet = (ISelectionSet2)pFeatSel.SelectionSet;
ISQLSyntax pSQLSyntax = (ISQLSyntax)pWS;
string sPref = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierPrefix);
string sSuff = pSQLSyntax.GetSpecialCharacter(esriSQLSpecialCharacters.esriSQL_DelimitedIdentifierSuffix);
if (bShowProgressor)
{
pProgressorDialog.ShowDialog();
pStepProgressor.Message = "Collecting Control point data...";
}
//Add the OIDs of all the selected control points into a new feature IDSet
string[] sOIDListPoints = { "(" };
int tokenLimit = 995;
//int tokenLimit = 5; //temp for testing
bool bCont = true;
int j = 0;
int iCounter = 0;
m_pFIDSetControl = new FIDSetClass();
ICursor pCursor = null;
pSelSet.Search(null, false, out pCursor);//code deletes all selected control points
IFeatureCursor pControlFeatCurs = (IFeatureCursor)pCursor;
IFeature pControlFeat = pControlFeatCurs.NextFeature();
int iPointID = pControlFeatCurs.FindField("POINTID");
while (pControlFeat != null)
{
//Check if the cancel button was pressed. If so, stop process
if (bShowProgressor)
{
bCont = pTrackCancel.Continue();
if (!bCont)
{
break;
}
}
bool bExists = false;
m_pFIDSetControl.Find(pControlFeat.OID, out bExists);
if (!bExists)
{
m_pFIDSetControl.Add(pControlFeat.OID);
object obj = pControlFeat.get_Value(iPointID);
if (iCounter <= tokenLimit)
{
//if the PointID is not null add it to a query string as well
if (obj != DBNull.Value)
{
sOIDListPoints[j] += Convert.ToString(obj) + ",";
}
iCounter++;
}
else
{//maximum tokens reached
//set up the next OIDList
sOIDListPoints[j] = sOIDListPoints[j].Trim();
iCounter = 0;
j++;
FabricUTILS.RedimPreserveString(ref sOIDListPoints, 1);
sOIDListPoints[j] = "(";
if (obj != DBNull.Value)
{
sOIDListPoints[j] += Convert.ToString(obj) + ",";
}
}
}
Marshal.ReleaseComObject(pControlFeat); //garbage collection
pControlFeat = pControlFeatCurs.NextFeature();
if (bShowProgressor)
{
if (pStepProgressor.Position < pStepProgressor.MaxRange)
{
pStepProgressor.Step();
}
}
}
Marshal.ReleaseComObject(pCursor); //garbage collection
if (!bCont)
{
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
return;
}
if (bUseNonVersionedDelete)
{
if (!FabricUTILS.StartEditing(pWS, bIsUnVersioned))
{
if (bUseNonVersionedDelete)
{
pCadEd.CadastralFabricLayer = null;
}
return;
}
}
//first delete all the control point records
if (bShowProgressor)
{
pStepProgressor.Message = "Deleting control points...";
}
bool bSuccess = true;
pPointsTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTPoints);
pControlTable = (ITable)pCadFabric.get_CadastralTable(esriCadastralFabricTable.esriCFTControl);
if (!bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsByFIDSet(pControlTable, m_pFIDSetControl, pStepProgressor, pTrackCancel);
}
if (bUseNonVersionedDelete)
{
bSuccess = FabricUTILS.DeleteRowsUnversioned(pWS, pControlTable,
m_pFIDSetControl, pStepProgressor, pTrackCancel);
}
if (!bSuccess)
{
AbortEdits(bUseNonVersionedDelete, pEd, pWS);
return;
}
//next need to use an in clause to update the points, ...
ICadastralFabricSchemaEdit2 pSchemaEd = (ICadastralFabricSchemaEdit2)pCadFabric;
//...for each item in the sOIDListPoints array
foreach (string inClause in sOIDListPoints)
{
string sClause = inClause.Trim().TrimEnd(',');
if (sClause.EndsWith("("))
{
continue;
}
if (sClause.Length < 3)
{
continue;
}
pSchemaEd.ReleaseReadOnlyFields(pPointsTable, esriCadastralFabricTable.esriCFTPoints);
m_pQF.WhereClause = (sPref + pPointsTable.OIDFieldName + sSuff).Trim() + " IN " + sClause + ")";
if (!FabricUTILS.ResetPointAssociations(pPointsTable, m_pQF, bIsUnVersioned))
{
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTPoints);
return;
}
pSchemaEd.ResetReadOnlyFields(esriCadastralFabricTable.esriCFTPoints);
}
}
if (bUseNonVersionedDelete)
{
FabricUTILS.StopEditing(pWS);
}
if (pEd.EditState == esriEditState.esriStateEditing)
{
pEd.StopOperation("Delete Control Points");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
finally
{
RefreshMap(pActiveView, CFControlLayers);
//update the TOC
IMxDocument mxDocument = (ESRI.ArcGIS.ArcMapUI.IMxDocument)(ArcMap.Application.Document);
for (int i = 0; i < mxDocument.ContentsViewCount; i++)
{
IContentsView pCV = (IContentsView)mxDocument.get_ContentsView(i);
pCV.Refresh(null);
}
if (pProgressorDialog != null)
{
pProgressorDialog.HideDialog();
}
if (bUseNonVersionedDelete)
{
pCadEd.CadastralFabricLayer = null;
CFControlLayers = null;
}
if (pMouseCursor != null)
{
pMouseCursor.SetCursor(0);
}
}
}
protected override void OnClick()
{
// **SAMPLE CODE NOTE**
// the following code show the mechanics of creating a new parcel using the ICadastralMapEdit interface
// there is no user interface to enter parcel record data, and the parcel line records are hard -coded
// for the purposes of this sample code. The center of the map extent is used as the point of beginning
// for the parcel.
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByName("esriCadastralUI.CadastralEditorExtension");
IParcelEditManager pParcEditorMan = (IParcelEditManager)pCadEd;
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esri object editor");
if (pEd.EditState == esriEditState.esriStateNotEditing)
{
MessageBox.Show("Please start editing and try again.");
return;
}
try
{
ICadastralPacketManager pCadPacketMan = (ICadastralPacketManager)pCadEd;
bool bStartedWithPacketOpen = pCadPacketMan.PacketOpen;
if (!bStartedWithPacketOpen)
{
pEd.StartOperation();
}
//1. Start map edit session
ICadastralMapEdit pCadMapEdit = (ICadastralMapEdit)pCadEd;
pCadMapEdit.StartMapEdit(esriMapEditType.esriMEEmpty, "NewParcel", false);
//2. Get job packet
ICadastralPacket pCadaPacket = pCadPacketMan.JobPacket;
//3. Create Plan (new)
string sPlanName = "My New Plan";
//first check to ensure plan is not already in the database.
IGSPlan pGSPlan = FindFabricPlanByName(sPlanName, pCadEd);
if (pGSPlan == null)
{
//if plan is null, it was not found and can be created
pGSPlan = new GSPlanClass();
// 3.a set values
pGSPlan.Accuracy = 4;
pGSPlan.Name = sPlanName;
}
//3.b Add the plan to the job packet
ICadastralPlan pCadaPlan = (ICadastralPlan)pCadaPacket;
pCadaPlan.AddPlan(pGSPlan);
//4. Create Parcel
ICadastralParcel pCadaParcel = (ICadastralParcel)pCadaPacket;
IGSParcel pNewGSParcel = new GSParcelClass();
//Make sure that any extended attributes on the parcel have their default values set
IGSAttributes pGSAttributes = (IGSAttributes)pNewGSParcel;
if (pGSAttributes != null)
{
ICadastralObjectSetup pCadaObjSetup = (ICadastralObjectSetup)pParcEditorMan;
pCadaObjSetup.AddExtendedAttributes(pGSAttributes);
pCadaObjSetup.SetDefaultValues(pGSAttributes);
}
//4a. Add the parcel to the packet. (do this before addlines)
// - This will enable us to Acquire the parcel ID,
// - Having the parcel attached to the packet allows InsertLine to function.
pCadaParcel.AddParcel(pNewGSParcel);
pNewGSParcel.Lot = "NewParcel";
pNewGSParcel.Type = 7;
//4b. Set Plan (created above)
IGSPlan thePlan = pCadaPlan.GetPlan(sPlanName);
pNewGSParcel.Plan = thePlan;
//4c. Insert GSLines (from new) into GSParcel
//4d. To bypass join, you can create GSPoints and assign those point IDs to the GSLines.
ICadastralPoints pCadaPoints = (ICadastralPoints)pCadaPacket;
IMetricUnitConverter pMetricUnitConv = (IMetricUnitConverter)pCadEd;
//Set up the initial start point, POB
//This sample code starts from the middle of the map, and defines 4 lines of a parcel
//The first course is a straight line, the other 3 courses are circular arcs
IArea pArea = (IArea)ArcMap.Document.ActiveView.Extent;
IPoint pPt1 = pArea.Centroid;
IZAware pZAw = (IZAware)pPt1;
pZAw.ZAware = true;
pPt1.Z = 0; //defaulting to 0
//Convert the point into metric units, and get a new (in-mem) point id
IGSPoint pGSPointFrom = pMetricUnitConv.SetGSPoint(pPt1);
pCadaPoints.AddPoint(pGSPointFrom);
int iID1 = pGSPointFrom.Id;
int index = 0;
//++++++++++++ Course 1 ++++++++++++++
int iID2 = -1;
//From, Direction (NAz Radians), Distance (map's projection units), Radius
IGSLine pGSLine = CreateGSLine(pMetricUnitConv, pCadaPoints, ref pPt1,
iID1, 0, 100, 0, -1, -1, -1, true, out iID2);
//Add the line to the new parcel
if (pGSLine != null)
{
pNewGSParcel.InsertLine(++index, pGSLine);
}
//++++++++++++ Course 2 ++++++++++++++
int iID3 = -1;
pGSLine = CreateGSLine(pMetricUnitConv, pCadaPoints, ref pPt1,
iID2, (Math.PI / 2), 100, -80, -1, -1, -1, true, out iID3);
if (pGSLine != null)
{
pNewGSParcel.InsertLine(++index, pGSLine);
}
//++++++++++++ Course 3 ++++++++++++++
int iID4 = -1;
pGSLine = CreateGSLine(pMetricUnitConv, pCadaPoints, ref pPt1,
iID3, Math.PI, 100, 80, -1, -1, -1, true, out iID4);
if (pGSLine != null)
{
pNewGSParcel.InsertLine(++index, pGSLine);
}
//++++++++++++ Course 4 ++++++++++++++
//close back to point of beginning
int i = -1;
pGSLine = CreateGSLine(pMetricUnitConv, pCadaPoints, ref pPt1,
iID4, (3 * Math.PI / 2), 100, 200, -1, -1, -1, false, out i);
pGSLine.ToPoint = iID1; //closing the traverse back to the POB
if (pGSLine != null)
{
pNewGSParcel.InsertLine(++index, pGSLine);
}
//Add radial lines for circular curves
pNewGSParcel.AddRadialLines();
// 4.e then set join=true on the parcel.
pNewGSParcel.Joined = true;
//let the packet know that a change has been made
pCadPacketMan.SetPacketModified(true);
//save the new parcel
try
{
pCadMapEdit.StopMapEdit(true);
}
catch
{
if (!bStartedWithPacketOpen)
{
pEd.AbortOperation();
}
return;
}
if (!bStartedWithPacketOpen)
{
pEd.StopOperation("New Parcel");
}
pCadPacketMan.PartialRefresh();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
protected override void OnClick()
{
IEditor pEd = (IEditor)ArcMap.Application.FindExtensionByName("esriEditor.Editor");
if (pEd.EditState == esriEditState.esriStateNotEditing)
{
MessageBox.Show("Please start editing and try again.");
return;
}
ICadastralEditor pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByName("esriCadastralUI.CadastralEditorExtension");
IParcelEditManager pParcEditorMan = (IParcelEditManager)pCadEd;
ICadastralSelection pCadaSel = (ICadastralSelection)pCadEd;
try
{
ICadastralPacketManager pCadPacketMan = (ICadastralPacketManager)pCadEd;
bool bStartedWithPacketOpen = pCadPacketMan.PacketOpen;
if (!bStartedWithPacketOpen)
{
pEd.StartOperation();
}
//1. Start map edit session
ICadastralMapEdit pCadMapEdit = (ICadastralMapEdit)pCadEd;
pCadMapEdit.StartMapEdit(esriMapEditType.esriMEParcelSelection, "Merge Parcel", false);
//2. Get job packet
ICadastralPacket pCadaPacket = pCadPacketMan.JobPacket;
//3. Create Plan (new)
string sPlanName = "My New Plan";
//first check to ensure plan is not already in the database.
IGSPlan pGSPlan = FindFabricPlanByName(sPlanName, pCadEd);
ICadastralPlan pCadaPlan = (ICadastralPlan)pCadaPacket;
if (pGSPlan == null)
{
//if plan is null, it was not found and can be created
pGSPlan = new GSPlanClass();
// 3.a set values
pGSPlan.Accuracy = 4;
pGSPlan.Name = sPlanName;
pGSPlan.DirectionFormat = esriDirectionType.esriDTQuadrantBearing;
pGSPlan.AngleUnits = esriDirectionUnits.esriDUDegreesMinutesSeconds;
pGSPlan.AreaUnits = esriCadastralAreaUnits.esriCAUAcre;
pGSPlan.Description = "My Test Plan for Merge";
pGSPlan.DistanceUnits = esriCadastralDistanceUnits.esriCDUFoot;
}
//3.b Add the plan to the job packet
pCadaPlan.AddPlan(pGSPlan);
ICadastralPoints pCadaPoints = (ICadastralPoints)pCadaPacket;
IConstructParcelFunctions3 constrParcelFunctions = new ParcelFunctions() as IConstructParcelFunctions3;
IEnumGSParcels selectedParcels = pCadaSel.SelectedParcels; //get selected parcels AFTER calling ::StartMapEdit to get the in-mem packet representation.
IGSParcel gsParcel = constrParcelFunctions.MergeParcels(pGSPlan, pCadaPoints, selectedParcels, pCadaPacket);
gsParcel.Type = 7; //7 = Tax parcel in the Local Government Information Model
gsParcel.Lot = "My Merged Tax Parcel";
ICadastralObjectSetup pCadaObjSetup = (ICadastralObjectSetup)pParcEditorMan;
//Make sure that any extended attributes on the new merged parcel have their default values set
IGSAttributes pGSAttributes = (IGSAttributes)gsParcel;
pCadaObjSetup.AddExtendedAttributes(pGSAttributes);
pCadaObjSetup.SetDefaultValues(pGSAttributes);
ICadastralParcel pCadaParcel = (ICadastralParcel)pCadaPacket;
pCadaParcel.AddParcel(gsParcel);
//set the original parcels to historic
selectedParcels.Reset();
IGSParcel selParcel = selectedParcels.Next();
while (selParcel != null)
{
selParcel.Historical = true;
//set SystemEndDate
pGSAttributes = (IGSAttributes)selParcel;
if (pGSAttributes != null)
{
pGSAttributes.SetProperty("systemenddate", DateTime.Now);
}
selParcel = selectedParcels.Next();
}
try
{
pCadMapEdit.StopMapEdit(true);
}
catch
{
if (!bStartedWithPacketOpen)
{
pEd.AbortOperation();
}
return;
}
if (!bStartedWithPacketOpen)
{
pEd.StopOperation("Merge Parcel");
}
pCadPacketMan.PartialRefresh();
}
catch (Exception ex)
{
pEd.AbortOperation();
MessageBox.Show(ex.Message);
}
}
public void RunManualRules()
{
ICursor cursor = null; IFeatureCursor fCursor = null;
bool ran = false;
try
{
//Get list of editable layers
IEditor editor = _editor;
IEditLayers eLayers = (IEditLayers)editor;
long lastOID = -1;
string lastLay = "";
if (_editor.EditState != esriEditState.esriStateEditing)
{
return;
}
IMap map = editor.Map;
IActiveView activeView = map as IActiveView;
IStandaloneTable stTable;
ITableSelection tableSel;
IStandaloneTableCollection stTableColl = (IStandaloneTableCollection)map;
long rowCount = stTableColl.StandaloneTableCount;
long rowSelCount = 0;
for (int i = 0; i < stTableColl.StandaloneTableCount; i++)
{
stTable = stTableColl.get_StandaloneTable(i);
tableSel = (ITableSelection)stTable;
if (tableSel.SelectionSet != null)
{
rowSelCount = rowSelCount + tableSel.SelectionSet.Count;
}
}
long featCount = map.SelectionCount;
int totalCount = (Convert.ToInt32(rowSelCount) + Convert.ToInt32(featCount));
if (totalCount >= 1)
{
editor.StartOperation();
if (MessageBox.Show("Are you sure you wish to apply attribute assistant manual rules for the selected " + totalCount + " rows and features?",
"Confirm", System.Windows.Forms.MessageBoxButtons.YesNo) == System.Windows.Forms.DialogResult.Yes)
{
ran = true;
//bool test = false;
//Get list of feature layers
UID geoFeatureLayerID = new UIDClass();
geoFeatureLayerID.Value = "{E156D7E5-22AF-11D3-9F99-00C04F6BC78E}";
IEnumLayer enumLayer = map.get_Layers(((ESRI.ArcGIS.esriSystem.UID)geoFeatureLayerID), true);
IFeatureLayer fLayer;
IFeatureSelection fSel;
ILayer layer;
// Step through each geofeature layer in the map
enumLayer.Reset();
// Create an edit operation enabling undo/redo
try
{
while ((layer = enumLayer.Next()) != null)
{
// Verify that this is a valid, visible layer and that this layer is editable
fLayer = (IFeatureLayer)layer;
if (fLayer.Valid && eLayers.IsEditable(fLayer))//fLayer.Visible &&
{
// Verify that this layer has selected features
IFeatureClass fc = fLayer.FeatureClass;
fSel = (IFeatureSelection)fLayer;
if ((fc != null) && (fSel.SelectionSet.Count > 0))
{
// test = true;
fSel.SelectionSet.Search(null, false, out cursor);
fCursor = cursor as IFeatureCursor;
IFeature feat;
while ((feat = (IFeature)fCursor.NextFeature()) != null)
{
lastLay = fLayer.Name;
lastOID = feat.OID;
IObject pObj = feat as IObject;
AAState.FeatureManual(pObj);
feat.Store();
}
if (feat != null)
{
Marshal.ReleaseComObject(feat);
}
}
}
}
}
catch (Exception ex)
{
editor.AbortOperation();
ran = false;
MessageBox.Show("RunManualRules\n" + ex.Message + " \n" + lastLay + ": " + lastOID, ex.Source);
return;
}
finally
{
//try
//{
// // Stop the edit operation
// editor.StopOperation("Run Manual Rules - Features");
//}
//catch (Exception ex)
//{ }
}
try
{
for (int i = 0; i < stTableColl.StandaloneTableCount; i++)
{
stTable = stTableColl.get_StandaloneTable(i);
tableSel = (ITableSelection)stTable;
if (tableSel.SelectionSet != null)
{
if (tableSel.SelectionSet.Count > 0)
{
tableSel.SelectionSet.Search(null, false, out cursor);
IRow pRow;
while ((pRow = (IRow)cursor.NextRow()) != null)
{
lastOID = pRow.OID;
lastLay = stTable.Name;
IObject pObj = pRow as IObject;
AAState.FeatureManual(pObj);
pRow.Store();
}
if (pRow != null)
{
Marshal.ReleaseComObject(pRow);
}
}
}
}
}
catch (Exception ex)
{
editor.AbortOperation();
MessageBox.Show("RunManualRules\n" + ex.Message + " \n" + lastLay + ": " + lastOID, ex.Source);
ran = false;
return;
}
finally
{
//try
//{
// Stop the edit operation
// editor.StopOperation("Run Manual Rules - Features");
//}
//catch (Exception ex)
//{ }
}
try
{
editor.StopOperation("Run Manual Rules - Features");
}
catch
{
}
}
}
else
{
MessageBox.Show("Please select some features or rows to run this process.");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + " \n" + "RunManualRules", ex.Source);
ran = false;
return;
}
finally
{
if (ran)
{
MessageBox.Show("Process has completed successfully");
}
if (cursor != null)
{
Marshal.ReleaseComObject(cursor);
}
if (fCursor != null)
{
Marshal.ReleaseComObject(fCursor);
}
}
}
