public CommonSetCUStandardAttributes(IGTComponents p_component, string p_componentName) { m_oApp = GTClassFactory.Create <IGTApplication>(); m_oDataContext = m_oApp.DataContext; m_oComponents = p_component; m_componentName = p_componentName; }
private void SynchronizeWP() { try { foreach (IGTDDCKeyObject ddcObject in m_selectedObjects) { m_oGTTransactionManager.Begin("Process Synchronize WorkPoints for Copy Ancillary =" + ddcObject.FNO.ToString() + " FID = " + ddcObject.FID.ToString()); IGTKeyObject feature = m_dataContext.OpenFeature(ddcObject.FNO, ddcObject.FID); IGTComponents CUComponentsFeature = GTClassFactory.Create <IGTComponents>(); foreach (IGTComponent item in feature.Components) { if (item.CNO == 22) { CUComponentsFeature.Add(item); } } WorkPointOperations obj = new WorkPointOperations(CUComponentsFeature, feature, m_dataContext); obj.DoWorkpointOperations(); m_oGTTransactionManager.Commit(); m_oGTTransactionManager.RefreshDatabaseChanges(); } } catch { throw; } }
/// <summary> /// UpdateWorkpointComponents : Update Workpoint feature components. /// </summary> /// <param name="fno">Workpoint Fno</param> /// <param name="fid">Workpoint FID</param> /// <param name="workPointFeature">Workpoint Feature</param> /// <param name="geoUpdate">Bool value indicates the updation of geometry.</param> /// <param name="strStructureID">StructureID of Active Key Object</param> private void UpdateWorkpointComponents(short fno, int fid, IGTKeyObject workPointFeature, bool geoUpdate, string strStructureID, int ownerCount, bool isLinear) { IGTComponents workPointComponents = workPointFeature.Components; foreach (IGTComponent component in workPointComponents) { if (component.Name == "WORKPOINT_N" && geoUpdate) { UpdateWorkPointAttributes(component, strStructureID); } else if (component.Name == "WORKPOINT_CU_N" && ownerCount == 0 && isLinear == true) { UpdateWorkpointCUAttributes(workPointFeature.FID, component); } else if (component.Name == "WORKPOINT_CU_N" && isLinear == false) { UpdateWorkpointCUAttributes(workPointFeature.FID, component); } } IGTKeyObject oKeyObject = m_dataContext.OpenFeature(fno, fid); IGTGeometry gTGeometry = oKeyObject.Components.GetComponent(m_gtcommonFunctions.GetPrimaryGraphicCno(fno, true)).Geometry; customWorkPointCreator workPointCreator = new customWorkPointCreator(m_dataContext, gTGeometry.FirstPoint.X, gTGeometry.FirstPoint.Y); workPointCreator.SynchronizeWPCuLabel(workPointFeature); }
private void SynchronizeWP(IGTKeyObject p_KeyObjectFeature) { try { m_oGTTransactionManager.Begin("Synchronize WorkPoints for Repeat Reconductoring Feature =" + p_KeyObjectFeature.FNO.ToString() + " FID = " + p_KeyObjectFeature.FID.ToString()); IGTComponents CUComponentsOldFeature = GTClassFactory.Create <IGTComponents>(); foreach (IGTComponent item in p_KeyObjectFeature.Components) { if (item.CNO == 21 || item.CNO == 22) { CUComponentsOldFeature.Add(item); } } WorkPointOperations obj = new WorkPointOperations(CUComponentsOldFeature, p_KeyObjectFeature, m_iGtApplication.DataContext); obj.DoWorkpointOperations(); m_oGTTransactionManager.Commit(); m_oGTTransactionManager.RefreshDatabaseChanges(); } catch (Exception ex) { if (m_oGTTransactionManager.TransactionInProgress) { m_oGTTransactionManager.Rollback(); } throw ex; } }
private void ProcessWPSync(IGTDDCKeyObject selectedObject) { try { WorkPointOperations oWorkPointOperations = null; IGTComponents gTComponents = GTClassFactory.Create <IGTComponents>(); IGTKeyObject feature = m_iGtApplication.DataContext.OpenFeature(selectedObject.FNO, selectedObject.FID); Recordset cuComponentRs = feature.Components.GetComponent(21).Recordset; if (cuComponentRs != null && cuComponentRs.RecordCount > 0) { gTComponents.Add(feature.Components.GetComponent(21)); } // Set Activity in Ancillary CU attributes if (feature.Components.GetComponent(22) != null) { Recordset acuComponentRs = feature.Components.GetComponent(22).Recordset; if (acuComponentRs != null && acuComponentRs.RecordCount > 0) { gTComponents.Add(feature.Components.GetComponent(22)); } } // Synchronize the workpoint oWorkPointOperations = new WorkPointOperations(gTComponents, feature, m_DataContext); oWorkPointOperations.DoWorkpointOperations(); } catch (Exception) { throw; } }
/// <summary> /// Method for Workpoint operations after command execution /// </summary> private void SynchronizeWP() { IGTComponents allCUComponents = null; try { foreach (IGTDDCKeyObject ddcobject in m_ooddcKeyObjects) { m_ofeature = m_oGTApp.Application.DataContext.OpenFeature(ddcobject.FNO, ddcobject.FID); allCUComponents = GTClassFactory.Create <IGTComponents>(); if (m_ofeature != null) { GetAllCUComponents(m_ofeature, ref allCUComponents); if (allCUComponents.Count > 0) { WorkPointOperations oWorkPointOperations = new WorkPointOperations(allCUComponents, m_ofeature, m_oGTApp.Application.DataContext); oWorkPointOperations.DoWorkpointOperations(); } } } } catch { throw; } }
/// <summary> /// Method to Get Component Values Of Differnt Feature /// </summary> /// <param name="m_trgComponents">Target Component Number</param> /// <param name="m_srcComponent">Source Component Number</param> /// <param name="k"> Edit index</param> /// <returns></returns> private void GetComponentValuesOfDifferntFeature(IGTComponents m_trgComponents, IGTComponent m_srcComponent, int k) { try { foreach (IGTComponent m_trgComponent in m_trgComponents) { //check if target component type is same as source component type if ((GetGeometryType(m_trgComponent.CNO) == (GetGeometryType(m_srcComponent.CNO))) && (m_trgComponent.TableName != m_srcComponent.TableName) && (GetDetail(m_trgComponent.CNO) == 0)) { //check if source geometry is valid, if so add to edit service if ((m_srcComponent.Geometry != null && m_trgComponent.Geometry == null)) { m_oEditService.AddGeometry(m_srcComponent.Geometry, m_styleID); m_EditObjects.Add(k, m_trgComponent.CNO); m_iEditIndex++; break; } } } } catch { throw; } }
/// <summary> /// Set Right Node Values /// </summary> /// <param name="m_gtComponents"></param> /// <param name="m_gtRelativePoint"></param> /// <param name="m_gtLineGeometry"></param> /// <returns></returns> private IGTPoint GetRightOriginPoint(IGTComponents m_gtComponents, IGTKeyObject m_gtRelativePoint, IGTGeometry m_gtLineGeometry) { try { IGTPoint m_gtRightOriginPoint = null; //set the node value for Bypass point placed at Right if ((m_rlnode1 != 0) && (m_rlnode1 == m_rpnode2)) { m_gtRightOriginPoint = PointAtDistanceBetweenTwoPoints(m_gtLineGeometry.LastPoint, m_gtLineGeometry.FirstPoint, xOffset, 0); m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = m_rlnode1; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = 0; m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Update(); m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Update(); } else { m_gtRightOriginPoint = PointAtDistanceBetweenTwoPoints(m_gtLineGeometry.FirstPoint, m_gtLineGeometry.LastPoint, -xOffset, 0); m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = 0; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = 0; m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Update(); m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Update(); } return(m_gtRightOriginPoint); } catch { throw; } }
/// <summary> /// Get Left Origin Point /// </summary> /// <param name="m_gtComponents"></param> /// <param name="m_gtRelativePoint"></param> /// <param name="m_gtLineGeometry"></param> /// <returns></returns> private IGTPoint GetLeftOriginPoint(IGTKeyObject m_KeyObject, IGTComponents m_gtComponents, IGTKeyObject m_gtRelativePoint, IGTGeometry m_gtLineGeometry, IGTKeyObjects m_gtRelativeLines) { try { //Get Left Origin Point IGTPoint m_gtLeftOriginPoint = null; IGTRelationshipService m_gtRelationshipService = GTClassFactory.Create <IGTRelationshipService>(); m_gtRelationshipService.DataContext = m_gtApplication.DataContext; if (m_rlnode2 != 0) { m_gtLeftOriginPoint = PointAtDistanceBetweenTwoPoints(m_gtLineGeometry.FirstPoint, m_gtLineGeometry.LastPoint, xOffset, 0); m_gtRelativeLines[0].Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = 0; m_gtRelativeLines[0].Components.GetComponent(ConnectivityCNO).Recordset.Update(); //establish the relationship m_gtRelationshipService.ActiveFeature = m_KeyObject; m_gtRelationshipService.SilentEstablish(iRNO, m_gtRelativeLines[0], GTRelationshipOrdinalConstants.gtrelRelationshipOrdinal1, GTRelationshipOrdinalConstants.gtrelRelationshipOrdinal2); m_gtRelativeLines[0].Components.GetComponent(ConnectivityCNO).Recordset.Update(); m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Update(); } else { m_gtLeftOriginPoint = PointAtDistanceBetweenTwoPoints(m_gtLineGeometry.LastPoint, m_gtLineGeometry.FirstPoint, -xOffset, 0); m_gtRelativeLines[0].Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = 0; m_gtRelativeLines[0].Components.GetComponent(ConnectivityCNO).Recordset.Update(); m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Update(); } m_gtRelationshipService = null; return(m_gtLeftOriginPoint); } catch { throw; } }
private void ModifiedCUComponentCollection() { try { foreach (KeyValuePair <IGTKeyObject, IGTComponents> gtKeyObject in m_gTKeyObjects) { IGTComponents gTCUComponents = GTClassFactory.Create <IGTComponents>(); m_gtAllCUComponents = GTClassFactory.Create <IGTComponents>(); m_activeKeyObject = gtKeyObject.Key; m_gtActiveFno = m_activeKeyObject.FNO; m_gtAllCUComponents = gtKeyObject.Value; if (m_gtAllCUComponents.Count > 0 && m_gtcommonFunctions.ISPrimaryGraphicComponentExist(m_activeKeyObject.FNO, m_activeKeyObject.FID)) { m_CUCompModified = true; ProcessModifiedCUComponents(); } } } catch { throw; } }
public void SetComponentsChanged(IGTComponents gTChangedComponents) { Recordset rs = null; try { foreach (IGTComponent gtComp in gTChangedComponents) { rs = gtComp.Recordset; if (rs != null && rs.RecordCount > 0) { rs.MoveFirst(); while (!rs.EOF) { foreach (Field field in rs.Fields) { if (field.OriginalValue.ToString() != field.Value.ToString()) { if (!m_gtAllCUComponents.Contains(gtComp))//Added by Prathyusha { m_gtAllCUComponents.Add(gtComp); } break; } } rs.MoveNext(); } } } } catch { throw; } }
public Dictionary <IGTKeyObject, IGTComponents> GetComponentsChangedCollection(IGTKeyObjects p_KeyObjects) { Dictionary <IGTKeyObject, IGTComponents> dicReturn = new Dictionary <IGTKeyObject, IGTComponents>(); IGTComponents gTCUComponents = GTClassFactory.Create <IGTComponents>(); try { foreach (IGTKeyObject oKeyObject in p_KeyObjects) { if (oKeyObject.Components.GetComponent(21) != null) { gTCUComponents.Add(oKeyObject.Components.GetComponent(21)); } if (oKeyObject.Components.GetComponent(22) != null) { gTCUComponents.Add(oKeyObject.Components.GetComponent(22)); } IGTComponents oCompCollection = SetComponentsChanged(gTCUComponents); if (oCompCollection.Count > 0) { dicReturn.Add(oKeyObject, oCompCollection); } } } catch { throw; } return(dicReturn); }
/// <summary> /// Method to check if the feature is an Isolation Scenario feature. /// </summary> /// <param name="gtComps">IGTComponents used to check for specific attribute values</param> /// <param name="fno">Feature number to check</param> /// <param name="isIsolationScenario">Indicates if feature takes part in an Isolation Scenario</param> /// <param name="isolationScenarioType">Type of Isolation Scenario. Set if isIsolationScenario is true</param> /// <returns>Boolean indicating method execution status</returns> private bool CheckIsoScenarioFeature(IGTComponents gtComps, short fno, ref bool isIsolationScenario, ref IsolationScenarios isolationScenarioType) { try { string feedType = string.Empty; if (fno == 59 && gtComps.GetComponent(5901).Recordset != null && gtComps.GetComponent(5901).Recordset.RecordCount > 0) { gtComps.GetComponent(5901).Recordset.MoveFirst(); feedType = Convert.ToString(gtComps.GetComponent(5901).Recordset.Fields["FEED_TYPE"].Value); } else if (fno == 60 && gtComps.GetComponent(6002).Recordset != null && gtComps.GetComponent(6002).Recordset.RecordCount > 0) { gtComps.GetComponent(6002).Recordset.MoveFirst(); feedType = Convert.ToString(gtComps.GetComponent(6002).Recordset.Fields["FEED_TYPE"].Value); } //ISODUAL if (fno == 34) //Autotransformer { isIsolationScenario = true; isolationScenarioType = IsolationScenarios.ISODUAL; } //ISOSINGLE else if (fno == 4 || fno == 12 || fno == 59 || (fno == 60 && feedType.ToUpper() == "RADIAL")) { isIsolationScenario = true; isolationScenarioType = IsolationScenarios.ISOSINGLE; } //ISOSINGLE NETWORK FEATURES else if (fno == 99 || fno == 98) { isIsolationScenario = true; isolationScenarioType = IsolationScenarios.ISOSINGLE; } //ELBOW else if (fno == 5 || (fno == 60 && feedType.ToUpper() == "LOOP")) { isIsolationScenario = true; isolationScenarioType = IsolationScenarios.ELBOW; } //BYPASS else if (fno == 14 || fno == 15 || fno == 36) { isIsolationScenario = true; isolationScenarioType = IsolationScenarios.BYPASS; } else { isIsolationScenario = false; } return(true); } catch (Exception ex) { throw new Exception("Error from Isolation Scenario FI:CheckIsoScenarioFeature: " + ex.Message); } }
/// <summary> /// Get Left Origin Point /// </summary> /// <param name="m_gtComponents"></param> /// <param name="m_gtRelativePoint"></param> /// <param name="m_gtLineGeometry"></param> /// <returns></returns> private IGTPoint GetLeftOriginPoint(IGTComponents m_gtComponents, IGTKeyObject m_gtRelativePoint, IGTGeometry m_gtLineGeometry, IGTKeyObjects m_gtRelativeLines) { try { //Get Left Origin Point IGTPoint m_gtLeftOriginPoint = null; IGTRelationshipService m_gtRelationshipService = GTClassFactory.Create <IGTRelationshipService>(); if ((m_gtRelativePoint.FNO == transformerUGFNO) || (m_gtRelativePoint.FNO == AutotransfomerFNO)) { //establish the connectivity for Relative point with Linear feature EstablishRelationship(m_gtRelativePoint, m_gtRelativeLines); } else { //set the node value for Bypass point placed at top if (m_KeyObjectCollection[1] != null) { m_gtRelationshipService.DataContext = m_gtApplication.DataContext; m_gtRelationshipService.ActiveFeature = m_KeyObjectCollection[1]; m_gtRelationshipService.SilentDelete(iRNO); IGTComponent m_gtBypassComp = m_KeyObjectCollection[1].Components.GetComponent(ConnectivityCNO); m_gtBypassComp.Recordset.Fields["NODE_1_ID"].Value = 0; m_gtBypassComp.Recordset.Fields["NODE_2_ID"].Value = 0; m_gtBypassComp.Recordset.Update(); } } //set the node value for Bypass point placed at Left if ((m_rlnode2 != 0) && (m_rlnode2 == m_rpnode1)) { m_gtLeftOriginPoint = PointAtDistanceBetweenTwoPoints(m_gtLineGeometry.FirstPoint, m_gtLineGeometry.LastPoint, xOffset, 0); m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = m_rlnode2; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = 0; m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Update(); m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Update(); } else { m_gtLeftOriginPoint = PointAtDistanceBetweenTwoPoints(m_gtLineGeometry.LastPoint, m_gtLineGeometry.FirstPoint, -xOffset, 0); m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = 0; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = m_rlnode1; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = 0; m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Update(); m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Update(); } m_gtRelationshipService = null; return(m_gtLeftOriginPoint); } catch { throw; } }
/// <summary> /// Method to create work point feature /// </summary> /// <returns>Work point feature IGTKeyObject</returns> public IGTKeyObject CreateWorkPointFeature() { try { IGTKeyObject workPointFeature = m_dataContext.NewFeature(191); IGTComponents workPointComponents = workPointFeature.Components; int wpOffsetX = 0; int wpOffsetY = 0; GetWorkPointOffset(ref wpOffsetX, ref wpOffsetY); foreach (IGTComponent component in workPointComponents) { Recordset tempRs = component.Recordset; if (tempRs != null) { if (tempRs.RecordCount > 0) { if (component.CNO == 19102) // Work point symbol { IGTOrientedPointGeometry orientedPtGeometry = GTClassFactory.Create <IGTOrientedPointGeometry>(); IGTPoint point = GTClassFactory.Create <IGTPoint>(); point.X = m_locationX - wpOffsetX; point.Y = m_locationY - wpOffsetY; orientedPtGeometry.Origin = point; component.Geometry = orientedPtGeometry; } if (component.CNO == 19103) // Work point Label { IGTTextPointGeometry gTTextPointGeometry = GTClassFactory.Create <IGTTextPointGeometry>(); IGTPoint gTPoint = GTClassFactory.Create <IGTPoint>(); gTPoint.X = m_locationX - wpOffsetX; gTPoint.Y = m_locationY - wpOffsetY; gTTextPointGeometry.Origin = gTPoint; gTTextPointGeometry.Alignment = GTAlignmentConstants.gtalBottomCenter; component.Geometry = gTTextPointGeometry; component.Recordset.Update(); } } } } // Leader Line should end at a point 70% of the way toward the structure from center of the Work Point. m_locationX = m_locationX - wpOffsetX * .3; m_locationY = m_locationY - wpOffsetY * .3; CreateLeaderLine(workPointFeature, m_locationX, m_locationY); return(workPointFeature); } catch (Exception) { throw; } }
/// <summary> /// Method to set the activity attribute of the CU and ACU components /// </summary> /// <param name="selectedObject">Selected feature on map window</param> private void SetActivity(IGTDDCKeyObject selectedObject) { Recordset cuComponentRs = null; Recordset acuComponentRs = null; WorkPointOperations oWorkPointOperations = null; IGTComponents gTComponents = GTClassFactory.Create <IGTComponents>(); try { IGTKeyObject feature = m_iGtApplication.DataContext.OpenFeature(selectedObject.FNO, selectedObject.FID); // Set Activity in CU attributes cuComponentRs = feature.Components.GetComponent(21).Recordset; if (cuComponentRs != null && cuComponentRs.RecordCount > 0) { gTComponents.Add(feature.Components.GetComponent(21)); cuComponentRs.MoveFirst(); while (!cuComponentRs.EOF) { cuComponentRs.Fields["ACTIVITY_C"].Value = "A"; cuComponentRs.MoveNext(); } } // Set Activity in Ancillary CU attributes if (feature.Components.GetComponent(22) != null) { acuComponentRs = feature.Components.GetComponent(22).Recordset; if (acuComponentRs != null && acuComponentRs.RecordCount > 0) { gTComponents.Add(feature.Components.GetComponent(22)); acuComponentRs.MoveFirst(); while (!acuComponentRs.EOF) { string retiremenType = Convert.ToString(acuComponentRs.Fields["RETIREMENT_C"].Value); if (retiremenType == "1" || retiremenType == "2") { acuComponentRs.Fields["ACTIVITY_C"].Value = "R"; } acuComponentRs.MoveNext(); } } } //// Synchronize the workpoint //oWorkPointOperations = new WorkPointOperations(gTComponents, feature, m_DataContext); //oWorkPointOperations.DoWorkpointOperations(); } catch (Exception) { throw; } }
/// <summary> /// Gets the values to pre-populate on the report. /// </summary> /// <param name="fno">G3E_FNO of the selected conductor</param> /// <param name="fid">G3E_FID of the selected conductor</param> /// <returns>Boolean indicating status</returns> private bool GetReportData(short fno, int fid) { bool returnValue = false; try { string cu = string.Empty; string location = string.Empty; if (fid != 0) { IGTKeyObject oGTKey = m_Application.DataContext.OpenFeature(fno, fid); IGTComponents oGTComponents = oGTKey.Components; Recordset componentRS = oGTComponents.GetComponent(ConstantsDT.CNO_COMPUNIT).Recordset; if (componentRS.RecordCount > 0) { cu = componentRS.Fields[ConstantsDT.FIELD_COMPUNIT_CU].Value.ToString(); } componentRS = oGTComponents.GetComponent(ConstantsDT.CNO_COMMON).Recordset; if (componentRS.RecordCount > 0) { location = componentRS.Fields[ConstantsDT.FIELD_COMMON_LOCATION].Value.ToString(); } } m_EmbeddedDT.ReportName = ConstantsDT.COMMAND_NAME_SAG_CLEARANCE + " " + m_Application.DataContext.ActiveJob + "-" + fid + ".pdf"; List <KeyValuePair <string, string> > reportValues = new List <KeyValuePair <string, string> >(); // Add report values reportValues.Add(new KeyValuePair <string, string>(ConstantsDT.REPORT_PARAMETER_SAG_PROJECT, CommonDT.WrDescription)); reportValues.Add(new KeyValuePair <string, string>(ConstantsDT.REPORT_PARAMETER_SAG_LOCATION, location)); reportValues.Add(new KeyValuePair <string, string>(ConstantsDT.REPORT_PARAMETER_SAG_DESIGNER, Environment.UserName)); reportValues.Add(new KeyValuePair <string, string>(ConstantsDT.REPORT_PARAMETER_SAG_DATE, DateTime.Now.ToShortDateString())); reportValues.Add(new KeyValuePair <string, string>(ConstantsDT.REPORT_PARAMETER_SAG_CONDUCTOR, cu)); m_EmbeddedDT.ReportValues = reportValues; returnValue = true; } catch (Exception ex) { MessageBox.Show(m_Application.ApplicationWindow, ConstantsDT.ERROR_RETRIEVING_REPORT_DATA + ": " + ex.Message, ConstantsDT.APPLICATION_NAME, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); return(false); } return(returnValue); }
private void SetStructureID() { string sOldFeatureStructureID = string.Empty; IGTComponents oldFeatureComponents = m_dataContext.OpenFeature(m_oldFeature.FNO, m_oldFeature.FID).Components; if (oldFeatureComponents.GetComponent(1).Recordset != null) { if (oldFeatureComponents.GetComponent(1).Recordset.RecordCount > 0) { oldFeatureComponents.GetComponent(1).Recordset.MoveFirst(); sOldFeatureStructureID = Convert.ToString(oldFeatureComponents.GetComponent(1).Recordset.Fields["STRUCTURE_ID"].Value); m_newFeature.Components.GetComponent(1).Recordset.Fields["STRUCTURE_ID"].Value = sOldFeatureStructureID; } } }
public void SynchronizeWP(IGTKeyObject p_keyObject) { IGTComponents CUComponentsNewFeature = GTClassFactory.Create <IGTComponents>(); foreach (IGTComponent item in p_keyObject.Components) { if (item.CNO == 21 || item.CNO == 22) { CUComponentsNewFeature.Add(item); } } WorkPointOperations obj = new WorkPointOperations(CUComponentsNewFeature, p_keyObject, m_dataContext); obj.DoWorkpointOperations(); }
/// <summary> /// Object initialization for the WorkPointOperations class /// </summary> /// <param name="AllCUComponents"> This is collection of Primary and Ancillary CUs component that are chabnged for which Workpoints oprtaiton is needed</param> /// <param name="ActiveKeyObject"> Active Object</param> /// <param name="DataContext"> Data Context</param> public WorkPointOperations(IGTComponents AllCUComponents, IGTKeyObject ActiveKeyObject, IGTDataContext DataContext, Dictionary <IGTKeyObject, IGTComponents> p_FeaturesCollection = null) { m_gtcommonFunctions = new CommonFunctions(); m_NewWorkpointFidList = new Dictionary <int, int>(); m_gtAllCUComponents = AllCUComponents; m_activeKeyObject = ActiveKeyObject; m_dataContext = DataContext; if (ActiveKeyObject != null) { m_gtActiveFno = ActiveKeyObject.FNO; } m_gTKeyObjects = p_FeaturesCollection; // m_calledFromCC = p_CalledFromCC; }
/// <summary> /// Method Create new feature /// </summary> /// <param name="srcFno">Source Feature Number</param> /// <param name="trgFno">Traget Feature Number</param> /// <returns></returns> private bool CopyFeature(short srcFno, short trgFno) { try { IGTComponents m_srcComponents = m_oGTApplication.DataContext.OpenFeature(srcFno, m_sourceFID).Components; m_otrgFeature = m_oGTApplication.DataContext.NewFeature(trgFno); IGTComponents m_trgComponents = m_oGTApplication.DataContext.OpenFeature(trgFno, m_otrgFeature.FID).Components; foreach (IGTComponent m_srcComponent in m_srcComponents) { Recordset rsOldFeature = m_srcComponent.Recordset; //Get target component if target component is same as source component m_trgComponent = m_otrgFeature.Components.GetComponent(m_srcComponent.CNO); //if target component is null for different feature type if (m_trgComponent == null) { if (GetComponentType(m_srcComponent.CNO) != 1) { GetComponentValuesOfDifferntFeature(m_trgComponents, m_srcComponent, m_iEditIndex); } } //if target component is not null else { Recordset rsNewFeature = m_trgComponent.Recordset; //check if target component is 3 if so then set the values if (rsNewFeature != null) { if (m_trgComponent.CNO == 3) { int m_newG3eId = Convert.ToInt32(rsNewFeature.Fields["G3E_ID"].Value); rsNewFeature.Fields["CREATED_BY"].Value = m_oGTApplication.DataContext.DatabaseUserName; rsNewFeature.Fields["CREATED_DATE"].Value = System.DateTime.Today; rsNewFeature.Fields["SOURCE"].Value = rsOldFeature.Fields["SOURCE"].Value; rsNewFeature.Fields["STAGE"].Value = "Accepted"; } else { GetComponentValuesOfSameFeature(rsNewFeature, rsOldFeature, m_trgComponent, m_srcComponent, m_iEditIndex); } } } } return(true); } catch { throw; } }
public Dictionary <IGTKeyObject, IGTComponents> GetFeatureComponentCollection() { Dictionary <IGTKeyObject, IGTComponents> oReturnCollection = new Dictionary <IGTKeyObject, IGTComponents>(); IGTJobManagementService oJobManagement = GTClassFactory.Create <IGTJobManagementService>(); try { oJobManagement.DataContext = m_oApp.DataContext; ADODB.Recordset rs = oJobManagement.FindPendingEdits(); if (rs != null && rs.RecordCount > 0) { foreach (IGTKeyObject item in m_featureKeyObject) { Feature obj = new Feature(item, m_oApp); rs.Filter = "g3e_fid = " + item.FID; if (rs != null && rs.RecordCount > 0) { IGTComponents oFeatureEditedComp = obj.GetEditedCUComponents(item, rs); if (oFeatureEditedComp.Count > 0 && (!oReturnCollection.Contains(new KeyValuePair <IGTKeyObject, IGTComponents>(item, oFeatureEditedComp)))) { oReturnCollection.Add(item, oFeatureEditedComp); } } rs.Filter = ADODB.FilterGroupEnum.adFilterNone; } } } catch (Exception ex) { string exMsg = string.Format("Error occurred in {0} of {1}.{2}{3}", System.Reflection.MethodBase.GetCurrentMethod().Name, this.ToString(), Environment.NewLine, ex.Message); throw new Exception(exMsg); } return(oReturnCollection); }
private void GetAllCUComponents(IGTKeyObject feature, ref IGTComponents allCUComponents) { try { foreach (IGTComponent component in feature.Components) { if (component.CNO == 21 || component.CNO == 22) { if (component != null) { if (component.Recordset != null && component.Recordset.RecordCount > 0) { allCUComponents.Add(component); } } } } } catch { throw; } }
/// <summary> /// Get Origin point of point feature /// </summary> /// <param name="m_gtComponents"></param> /// <param name="gtRelativeComponent"></param> /// <param name="xOffset"></param> /// <param name="pointLocation"></param> /// <returns></returns> private IGTPoint GetOrigin(IGTKeyObject m_KeyObject, IGTComponents m_gtComponents, IGTGraphicComponent m_gtRelativeComponent, double xOffset, string pointLocation) { try { IGTPoint m_gtOriginPoint = null; IGTGeometry m_gtLineGeometry = GTClassFactory.Create <IGTGeometry>(); m_gtApplication.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, currentKeyObject + " Point placement is in Progress......"); //Get Relative Component IGTKeyObject m_gtRelativePoint = m_gtApplication.DataContext.OpenFeature(m_gtRelativeComponent.FNO, m_gtRelativeComponent.FID); //get the related Linear features IGTKeyObjects m_gtRelativeLines = GetRelatedFeature(m_gtRelativePoint, iRNO, linearFNO); //get the related Linear features in case they are not connected to relativepoint if (m_gtRelativeLines.Count == 0) { IGTKeyObjects m_gtBypasspt = GetRelatedFeature(m_gtRelativePoint, iRNO, m_KeyObject.FNO); if (m_gtBypasspt.Count > 0) { m_gtRelativeLines = GetRelatedFeature(m_gtBypasspt[0], iRNO, linearFNO); } } //Check if related line geometry is not null if (m_gtRelativeLines != null && m_gtRelativeLines.Count > 0) { //Get node values m_gtRelativeLines = GetNodeValues(m_gtRelativePoint, m_gtRelativeLines); m_gtLineGeometry = m_gtRelativeLines[0].Components.GetComponent(primaryCNO).Geometry; //Get Line segment and its angle m_gtLineGeometry = GetSegmentAndAngle(m_gtLineGeometry, m_gtRelativeComponent.Geometry.FirstPoint); if (m_gtLineGeometry != null) { switch (pointLocation) { case "L": //Get Left Origin Point m_gtOriginPoint = GetLeftOriginPoint(m_gtComponents, m_gtRelativePoint, m_gtLineGeometry, m_gtRelativeLines); break; case "R": //Get Right Origin Point m_gtOriginPoint = GetRightOriginPoint(m_gtComponents, m_gtRelativePoint, m_gtLineGeometry); break; case "T": //Get Top Origin Point m_gtOriginPoint = GetTopOriginPoint(m_gtLineGeometry); //establish the connectivity for Relative point with Linear feature EstablishRelationship(m_gtRelativePoint, m_gtRelativeLines); break; default: break; } if (m_gtOriginPoint == null) { m_gtOriginPoint = m_gtRelativeComponent.Geometry.FirstPoint; } } else { if (pointLocation == "R") { MessageBox.Show("Error: Unable to place " + currentKeyObject + " Points as the linear feature is not selected properly", "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Error); } } } return(m_gtOriginPoint); } catch { throw; } }
public IGTComponents GetEditedCUComponents(IGTKeyObject p_KeyObject, ADODB.Recordset p_RecordSet) { IGTComponents oEditedComponentCollection = GTClassFactory.Create <IGTComponents>(); Dictionary <Int32, Int16> oDic = new Dictionary <Int32, Int16>(); bool bPrimaryGeoemtryEdited = false; bool bCommonComponentEdited = false; string sStrcurure_ID = string.Empty; bool bAncillaryEdited = false; bool bPrimaryCUEdited = false; try { if (p_RecordSet != null) { if (p_RecordSet.RecordCount > 0) { p_RecordSet.MoveFirst(); while (p_RecordSet.EOF == false) { int FID = Convert.ToInt32(p_RecordSet.Fields["g3e_fid"].Value); Int16 FNO = Convert.ToInt16(p_RecordSet.Fields["g3e_fno"].Value); int CNO = Convert.ToInt32(p_RecordSet.Fields["g3e_cno"].Value); if (CNO == 22) { oEditedComponentCollection.Add(p_KeyObject.Components.GetComponent(22)); bAncillaryEdited = true; } if (CNO == 21) { oEditedComponentCollection.Add(p_KeyObject.Components.GetComponent(21)); bPrimaryCUEdited = true; } if (CNO == 1) { bCommonComponentEdited = true; p_KeyObject.Components.GetComponent(1).Recordset.MoveFirst(); sStrcurure_ID = Convert.ToString(p_KeyObject.Components.GetComponent(1).Recordset.Fields["STRUCTURE_ID"].Value); } if (CNO.Equals(IsPrimaryGraphic(FNO))) { bPrimaryGeoemtryEdited = true; } p_RecordSet.MoveNext(); } if (bCommonComponentEdited && bPrimaryGeoemtryEdited && IsWPExist(sStrcurure_ID)) { if (p_KeyObject.Components.GetComponent(22) != null) { if (!bAncillaryEdited) { oEditedComponentCollection.Add(p_KeyObject.Components.GetComponent(22)); } } if (p_KeyObject.Components.GetComponent(21) != null) { if (!bPrimaryCUEdited) { oEditedComponentCollection.Add(p_KeyObject.Components.GetComponent(21)); } } } } } } catch (Exception ex) { string exMsg = string.Format("Error occurred in {0} of {1}.{2}{3}", System.Reflection.MethodBase.GetCurrentMethod().Name, this.ToString(), Environment.NewLine, ex.Message); throw new Exception(exMsg); } return(oEditedComponentCollection); }
/// <summary> /// Set Attribute value /// </summary> /// <param name="m_gtComponents"></param> /// <param name="m_gtKeyObject"></param> /// <param name="m_gtRelativeComponent"></param> /// <returns></returns> protected void SetAttributeValues(IGTComponents m_gtComponents, IGTKeyObject m_gtKeyObject, IGTGraphicComponent m_gtRelativeComponent) { try { foreach (IGTComponent m_gtComponent in m_gtComponents) { switch (m_gtComponent.CNO) { case VirtualPointCNO: if (m_gtComponent.Recordset.RecordCount == 0) { m_gtComponent.Recordset.AddNew(); m_gtComponent.Recordset.Fields["G3E_FID"].Value = m_gtKeyObject.FID; m_gtComponent.Recordset.Fields["G3E_FNO"].Value = m_gtKeyObject.FNO; m_gtComponent.Recordset.Fields["G3E_CNO"].Value = m_gtComponent.CNO; m_gtComponent.Recordset.Fields["G3E_CID"].Value = 1; } else { m_gtComponent.Recordset.MoveFirst(); } break; case ConnectivityCNO: if (m_gtComponent.Recordset.RecordCount == 0) { m_gtComponent.Recordset.AddNew(); m_gtComponent.Recordset.Fields["G3E_FID"].Value = m_gtKeyObject.FID; m_gtComponent.Recordset.Fields["G3E_FNO"].Value = m_gtKeyObject.FNO; m_gtComponent.Recordset.Fields["G3E_CNO"].Value = m_gtComponent.CNO; m_gtComponent.Recordset.Fields["G3E_CID"].Value = 1; m_gtComponent.Recordset.Fields["STATUS_NORMAL_C"].Value = statusNormal; } else { m_gtComponent.Recordset.MoveFirst(); m_gtComponent.Recordset.Fields["STATUS_NORMAL_C"].Value = statusNormal; } break; case VirtualAttributeCNO: if (m_gtComponent.Recordset.RecordCount == 0) { m_gtComponent.Recordset.AddNew(); m_gtComponent.Recordset.Fields["G3E_FID"].Value = m_gtKeyObject.FID; m_gtComponent.Recordset.Fields["G3E_FNO"].Value = m_gtKeyObject.FNO; m_gtComponent.Recordset.Fields["G3E_CNO"].Value = m_gtComponent.CNO; m_gtComponent.Recordset.Fields["G3E_CID"].Value = 1; m_gtComponent.Recordset.Fields["ASSOCIATED_FID"].Value = m_gtRelativeComponent.FID; m_gtComponent.Recordset.Fields["PERMANENT_YN"].Value = "Y"; } else { m_gtComponent.Recordset.MoveFirst(); m_gtComponent.Recordset.Fields["ASSOCIATED_FID"].Value = m_gtRelativeComponent.FID; m_gtComponent.Recordset.Fields["PERMANENT_YN"].Value = "Y"; } break; default: break; } } } catch { throw; } }
/// <summary> /// Get Origin /// </summary> /// <param name="m_gtComponents"></param> /// <param name="m_gtRelativeComponent"></param> /// <param name="xOffset"></param> /// <param name="pointLocation"></param> /// <returns></returns> private IGTPoint GetOrigin(IGTKeyObject KeyObject, IGTComponents m_gtComponents, IGTGraphicComponent m_gtRelativeComponent, double xOffset, string pointLocation) { try { IGTPoint m_gtOriginPoint = null; m_gtApplication.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, "Isolation Point placement is in Progress......"); //Get the related Point feature IGTKeyObject m_gtRelativePoint = m_gtApplication.DataContext.OpenFeature(m_gtRelativeComponent.FNO, m_gtRelativeComponent.FID); //get the related lines IGTKeyObjects m_gtRelativeLines = GetRelatedFeature(m_gtRelativePoint, iRNO, linearFNO); //get the related Linear features in case they are not connected to relativepoint if (m_gtRelativeLines.Count == 0) { IGTKeyObjects m_gtBypasspt = GetRelatedFeature(m_gtRelativePoint, iRNO, KeyobjectFNO); if (m_gtBypasspt.Count > 0) { m_gtRelativeLines = GetRelatedFeature(m_gtBypasspt[0], iRNO, linearFNO); } } //Check if related line geometry is not null if (m_gtRelativeLines != null && m_gtRelativeLines.Count > 0) { EstablishRelationship(m_gtRelativePoint, m_gtRelativeLines); IGTGeometry m_gtLineGeometry = m_gtRelativeLines[0].Components.GetComponent(primaryCNO).Geometry; if (m_gtLineGeometry != null) { //Get node values GetNodeValues(m_gtRelativePoint, m_gtRelativeLines); //create offset geoemtry if ((m_rlnode2 != 0) && (m_rlnode2 == m_rpnode1)) { IGTGeometry[] geoms = m_gtLineGeometry.CreateOffsetGeometries(xOffset); m_gtOriginPoint = geoms[0].LastPoint; //set the node value m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = m_rlnode2; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = 0; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = 0; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Update(); m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Update(); //set the node value if (m_gtRelativePoint.FNO == transformerUGFNO) { if (m_gtRelativeLines.Count > 1) { m_gtRelativeLines[1].Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = m_rlnode2; m_gtRelativeLines[1].Components.GetComponent(ConnectivityCNO).Recordset.Update(); } } } else { IGTGeometry[] geoms = m_gtLineGeometry.CreateOffsetGeometries(xOffset); m_gtOriginPoint = geoms[0].FirstPoint; //set the node value m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = m_rlnode1; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = 0; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_2_ID"].Value = 0; m_gtRelativePoint.Components.GetComponent(ConnectivityCNO).Recordset.Update(); m_gtComponents.GetComponent(ConnectivityCNO).Recordset.Update(); //set the node value if (m_gtRelativePoint.FNO == transformerUGFNO) { if (m_gtRelativeLines.Count > 1) { m_gtRelativeLines[1].Components.GetComponent(ConnectivityCNO).Recordset.Fields["NODE_1_ID"].Value = m_rlnode1; m_gtRelativeLines[1].Components.GetComponent(ConnectivityCNO).Recordset.Update(); } } } } if (m_gtOriginPoint == null) { m_gtOriginPoint = m_gtRelativeComponent.Geometry.FirstPoint; } } else { if (pointLocation == "R") { MessageBox.Show("Error: Unable to place Isolation Points as the linear feature is not selected properly", "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Error); } } return(m_gtOriginPoint); } catch (Exception) { throw; } }
/// <summary> /// Method to apply offset to removal feature / old feature /// </summary> /// <param name="sqlString"></param> /// <returns></returns> private void ApplyOffSetToGraphicComponents(short featureFNO, int featureFID) { IGTPoint point = null; try { IGTKeyObject feature = m_iGtApplication.DataContext.OpenFeature(featureFNO, featureFID); IGTComponents allComponents = feature.Components; feature.Components.GetComponent(1).Recordset.MoveFirst(); string sStructureID = Convert.ToString(feature.Components.GetComponent(1).Recordset.Fields["STRUCTURE_ID"].Value); foreach (IGTComponent component in allComponents) { if (!IsGraphicGeoComp(component.CNO)) { continue; } if (component.Geometry == null) { continue; } switch (component.Geometry.Type) { case GTGeometryTypeConstants.gtgtOrientedPointGeometry: IGTOrientedPointGeometry orientedPtGeometry = GTClassFactory.Create <IGTOrientedPointGeometry>(); point = GTClassFactory.Create <IGTPoint>(); point.X = component.Geometry.FirstPoint.X + m_offSetX; point.Y = component.Geometry.FirstPoint.Y + m_offSetY; orientedPtGeometry.Origin = point; orientedPtGeometry.Orientation = ((IGTOrientedPointGeometry)component.Geometry).Orientation; component.Geometry = orientedPtGeometry; break; case GTGeometryTypeConstants.gtgtTextPointGeometry: IGTTextPointGeometry textPtGeometry = GTClassFactory.Create <IGTTextPointGeometry>(); point = GTClassFactory.Create <IGTPoint>(); point.X = component.Geometry.FirstPoint.X + m_offSetX; point.Y = component.Geometry.FirstPoint.Y + m_offSetY; textPtGeometry.Origin = point; textPtGeometry.Normal = ((IGTOrientedPointGeometry)component.Geometry).Orientation; component.Geometry = textPtGeometry; break; case GTGeometryTypeConstants.gtgtPolylineGeometry: IGTPolylineGeometry newFtPlineGeo = GTClassFactory.Create <IGTPolylineGeometry>(); for (int k = 0; k <= component.Geometry.KeypointCount - 1; k++) { point = GTClassFactory.Create <IGTPoint>(); point.X = component.Geometry.GetKeypointPosition(k).X + m_offSetX; point.Y = component.Geometry.GetKeypointPosition(k).Y + m_offSetY; newFtPlineGeo.Points.Add(point); } component.Geometry = newFtPlineGeo; break; case GTGeometryTypeConstants.gtgtCompositePolylineGeometry: IGTCompositePolylineGeometry newFtCpline = GTClassFactory.Create <IGTCompositePolylineGeometry>(); IGTPolylineGeometry polylineGeometrytemp = GTClassFactory.Create <IGTPolylineGeometry>(); foreach (IGTGeometry subgeom in (IGTCompositePolylineGeometry)component.Geometry) { switch (subgeom.Type) { case GTGeometryTypeConstants.gtgtPointGeometry: case GTGeometryTypeConstants.gtgtOrientedPointGeometry: point.X = component.Geometry.FirstPoint.X + m_offSetX; point.Y = component.Geometry.FirstPoint.Y + m_offSetY; polylineGeometrytemp.Points.Add(point); break; case GTGeometryTypeConstants.gtgtLineGeometry: point.X = component.Geometry.FirstPoint.X + m_offSetX; point.Y = component.Geometry.FirstPoint.Y + m_offSetY; polylineGeometrytemp.Points.Add(point); point.X = component.Geometry.LastPoint.X + m_offSetX; point.Y = component.Geometry.LastPoint.Y + m_offSetY; polylineGeometrytemp.Points.Add(point); break; case GTGeometryTypeConstants.gtgtPolylineGeometry: for (int k = 0; k < subgeom.KeypointCount; k++) { point.X = component.Geometry.FirstPoint.X + m_offSetX; point.Y = component.Geometry.FirstPoint.Y + m_offSetY; polylineGeometrytemp.Points.Add(point); } break; } } break; default: break; } } feature.Components.GetComponent(1).Recordset.Fields["STRUCTURE_ID"].Value = sStructureID; //Reset the Structure ID to original value. The update is needed as Set Structure Locaiton FI changed the original Structure ID UpdateAssociatedWorkPointsStructureId(feature.FNO, feature.FID, sStructureID); //Update all the WP associated with the feature } catch (Exception) { throw; } }
/// <summary> /// StartPlacement /// </summary> /// <param name="PTHelper"></param> /// <param name="KeyObject"></param> /// <param name="KeyObjectCollection"></param> /// <returns></returns> public override void StartPlacement(IGTPlacementTechniqueHelper PTHelper, IGTKeyObject KeyObject, IGTKeyObjects KeyObjectCollection) { try { m_PTHelper = PTHelper; IGTKeyObject m_KeyObject = KeyObject; IGTPoint m_gtOrigin; IGTGraphicComponent relativeComponent = GTClassFactory.Create <IGTGraphicComponent>(); m_KeyObjectCollection = KeyObjectCollection; //get current Key object currentKeyObject = GetcurrentKeyObject(KeyObject.FNO); if (bSilent) { m_gtApplication.BeginWaitCursor(); // Disable construction aids and status bar prompts for silent placement techinque. m_PTHelper.ConstructionAidsEnabled = GTConstructionAidsEnabledConstants.gtptConstructionAidsNone; m_PTHelper.ConstructionAidDynamicsEnabled = false; m_PTHelper.StatusBarPromptsEnabled = true; m_gtApplication.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, currentKeyObject + " Point placement is in Progress......"); IGTComponents gtComponents = KeyObject.Components; m_PTHelper.StartPlacement(KeyObject, KeyObjectCollection); //Read arguments ReadArgument(); //Find the relative component defined in the placement technique arguments. if ((Convert.ToString(m_GComp.Arguments.GetArgument(0)) != "") && (m_GComps.Count > 0) && (m_GComp != null)) { relativeComponent = AccessRelativeComponent.RetrieveRelativeComponent(Convert.ToString(m_GComp.Arguments.GetArgument(0)), m_GComps, m_GComp); //get the origin m_gtOrigin = GetOrigin(m_KeyObject, gtComponents, relativeComponent, xOffset, pointLocation); if ((m_gtOrigin != null) && (relativeComponent != null)) { //Set Attribute values SetAttributeValues(gtComponents, m_KeyObject, relativeComponent); //Create new point geometry aligned to the linear feature IGTOrientedPointGeometry newPointGeometry = (IGTOrientedPointGeometry)PTHelper.CreateGeometry(); //newPointGeometry.Orientation = VectorByAngle(ang); newPointGeometry.Origin = m_gtOrigin; m_PTHelper.SetGeometry(newPointGeometry); m_PTHelper.EndPlacement(); } else { AbortPlacement(); } } else { if (pointLocation == "R") { MessageBox.Show("Error: Unable to place " + currentKeyObject + " Points", "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Error); } AbortPlacement(); } } } catch (Exception ex) { MessageBox.Show("Error: Unable to place " + currentKeyObject + " Points \n" + ex.Message, "G/Technology", MessageBoxButtons.OK, MessageBoxIcon.Error); AbortPlacement(); } finally { m_KeyObjectCollection = null; m_GComps = null; m_GComp = null; if (pointLocation == "R") { m_gtApplication.EndWaitCursor(); m_gtApplication.SetStatusBarText(GTStatusPanelConstants.gtaspcMessage, "Feature Placement Completed"); m_gtApplication.ActiveMapWindow.MousePointer = GTMousePointerConstants.gtmwmpNWArrow; m_PTHelper.ConstructionAidsEnabled = GTConstructionAidsEnabledConstants.gtptConstructionAidsNone; m_PTHelper.ConstructionAidDynamicsEnabled = false; } Exitcommand(); } }
//public RestrictedArea(short Fno, int Fid) //{ // m_fno = Fno; // m_fid = Fid; // m_iGtApplication = GTClassFactory.Create<IGTApplication>(); // m_iGtDataContext = m_iGtApplication.DataContext; //} /// <summary> /// Process Restricted Area validation /// </summary> /// <returns>true if the process is complete without errors, else returns false</returns> public bool Process() { IGTGeometry featureGeometry = null; IGTSpatialService gTSpatialService = null; IGTComponent restrictedAreaAttributes = null; try { foreach (IGTKeyObject feature in m_features) { m_fno = feature.FNO; m_fid = feature.FID; IGTComponents selectedfeatureComponents = m_iGtDataContext.OpenFeature(m_fno, m_fid).Components; CommonFunctions commonFunctions = new CommonFunctions(); short primaryCno = commonFunctions.GetPrimaryGraphicCno(m_fno, true); // If the CNO is zero (not defined), then try the detail CNO if (0 == primaryCno) { primaryCno = commonFunctions.GetPrimaryGraphicCno(m_fno, false); } IGTComponent primaryGraphicComponent = selectedfeatureComponents.GetComponent(primaryCno); if (primaryGraphicComponent != null) { Recordset graphicCompRs = primaryGraphicComponent.Recordset; if (graphicCompRs != null && graphicCompRs.RecordCount > 0) { graphicCompRs.MoveFirst(); // Retrieve the geometry of the primary graphic component featureGeometry = primaryGraphicComponent.Geometry; // Find any Restricted Area features whose area component overlaps the retrieved geometry; if none are found, return with a successful status. gTSpatialService = GTClassFactory.Create <IGTSpatialService>(); gTSpatialService.DataContext = m_iGtDataContext; gTSpatialService.Operator = GTSpatialOperatorConstants.gtsoEntirelyContainedBy; gTSpatialService.FilterGeometry = featureGeometry; Recordset restrictedAreaFeaturesRs = gTSpatialService.GetResultsByFNO(new short[] { RestrictedAreaFno }); if (restrictedAreaFeaturesRs != null && restrictedAreaFeaturesRs.RecordCount > 0) { //Prathyusha //if (restrictedAreaFeaturesRs.RecordCount == 0) //{ // return false; //} restrictedAreaFeaturesRs.MoveFirst(); while (!restrictedAreaFeaturesRs.EOF) { int fid = Convert.ToInt32(restrictedAreaFeaturesRs.Fields["G3E_FID"].Value); restrictedAreaAttributes = m_iGtDataContext.OpenFeature(RestrictedAreaFno, fid).Components.GetComponent(RestrictedAreaAttributesCno); if (!ValidateRestrictedAreaFeature(restrictedAreaAttributes)) { return(false); } restrictedAreaFeaturesRs.MoveNext(); } return(true); } } } } return(true);// Prathyusha: return false; } catch (Exception) { throw; } }