public bool IsValid(object caller, ICSharpCode.Core.Condition condition)
{
DF3DApplication app = DF3DApplication.Application;
if (app == null || app.Current3DMapControl == null)
{
return(false);
}
if (CommonUtils.Instance().CurEditLayer != null)
{
DF3DFeatureClass dffc = CommonUtils.Instance().CurEditLayer;
if (dffc != null)
{
string facType = dffc.GetFacilityClassName();
if (facType != "PipeLine" && facType != "PipeNode" && facType != "PipeBuild" && facType != "PipeBuild1")
{
IFeatureLayer fl = dffc.GetFeatureLayer();
if (fl != null)
{
if (fl.GeometryType == gviGeometryColumnType.gviGeometryColumnPoint)
{
return(true);
}
}
}
}
}
return(false);
}
public void GeometryEditStart(DF3DFeatureClass fcInfo, IRenderGeometry renderGeo, gviGeoEditType editType)
{
if (this._app == null || this._app.Current3DMapControl == null)
{
return;
}
if (this._geoEditor.IsEditing)
{
this.StopEdit(true);
}
this.curGeoField = fcInfo.GetFeatureLayer().GeometryFieldName;
this._renderGeometry = renderGeo;
this._FeatureClass = fcInfo;
Gvitech.CityMaker.FdeCore.IFeatureClass featureClass = fcInfo.GetFeatureClass();
this._row = featureClass.CreateRowBuffer();
int num = this._row.FieldIndex(this.curGeoField);
if (num != -1 && this._renderGeometry != null)
{
this._row.SetValue(num, this._renderGeometry.GetFdeGeometry());
}
this._geoEditType = editType;
this._InteractaMode = this._app.Current3DMapControl.InteractMode;
this._app.Current3DMapControl.InteractMode = gviInteractMode.gviInteractEdit;
if (!this._geoEditor.StartEditRenderGeometry(renderGeo, editType))
{
this._app.Current3DMapControl.InteractMode = this._InteractaMode;
XtraMessageBox.Show("暂不支持该类型的编辑");
}
//System.Runtime.InteropServices.Marshal.ReleaseComObject(featureClass);
}
public bool IsValid(object caller, ICSharpCode.Core.Condition condition)
{
DF3DApplication app = DF3DApplication.Application;
if (app == null || app.Current3DMapControl == null)
{
return(false);
}
DF3DFeatureClass dffc = CommonUtils.Instance().CurEditLayer;
if (dffc == null)
{
return(false);
}
IFeatureClass fc = dffc.GetFeatureClass();
if (fc == null)
{
return(false);
}
IFeatureLayer fl = dffc.GetFeatureLayer();
bool b1 = false;
if (fl != null && (fl.GeometryType == gviGeometryColumnType.gviGeometryColumnPolygon || fl.GeometryType == gviGeometryColumnType.gviGeometryColumnPolyline))
{
b1 = true;
}
int count = SelectCollection.Instance().GetCount(false);
if (count != 1)
{
b1 &= false;
}
return(b1);
}
public void GeometryEditStart(DF3DFeatureClass fcInfo, Gvitech.CityMaker.FdeCore.IRowBuffer row, gviGeoEditType editType)
{
if (this._app == null || this._app.Current3DMapControl == null)
{
return;
}
if (this._geoEditor.IsEditing)
{
this.StopEdit(true);
}
this.curGeoField = fcInfo.GetFeatureLayer().GeometryFieldName;
this._FeatureClass = fcInfo;
this._row = row;
this._geoEditType = editType;
this._InteractaMode = this._app.Current3DMapControl.InteractMode;
this._app.Current3DMapControl.InteractMode = gviInteractMode.gviInteractEdit;
if (!this._geoEditor.StartEditFeatureGeometry(row, fcInfo.GetFeatureLayer(), editType))
{
this._app.Current3DMapControl.InteractMode = this._InteractaMode;
XtraMessageBox.Show("暂不支持该类型的编辑");
}
}
public override object this[object key]
{
get
{
DF3DFeatureClass featureClassInfo = key as DF3DFeatureClass;
if (featureClassInfo == null)
{
return(null);
}
foreach (DF3DFeatureClass featureClassInfo2 in this.Keys)
{
if (featureClassInfo2.GetFeatureLayer().Guid == featureClassInfo.GetFeatureLayer().Guid)
{
return(base[featureClassInfo2]);
}
}
return(null);
}
set
{
base[key] = value;
}
}
public override void Run(object sender, System.EventArgs e)
{
DF3DApplication app = DF3DApplication.Application;
if (app == null || app.Current3DMapControl == null)
{
return;
}
try
{
Map3DCommandManager.Push(this);
RenderControlEditServices.Instance().StopGeometryEdit(true);
app.Current3DMapControl.PauseRendering(false);
System.Collections.Generic.IList <System.Collections.Generic.KeyValuePair <int, string> > list = new System.Collections.Generic.List <System.Collections.Generic.KeyValuePair <int, string> >();
HashMap featureClassInfoMap = SelectCollection.Instance().FeatureClassInfoMap;
DF3DFeatureClass featureClassInfo = null;
System.Collections.Generic.IList <int> list2 = new System.Collections.Generic.List <int>();
System.Collections.IEnumerator enumerator = featureClassInfoMap.Keys.GetEnumerator();
try
{
if (enumerator.MoveNext())
{
DF3DFeatureClass featureClassInfo2 = (DF3DFeatureClass)enumerator.Current;
featureClassInfo = featureClassInfo2;
ResultSetInfo resultSetInfo = featureClassInfoMap[featureClassInfo2] as ResultSetInfo;
foreach (DataRow dataRow in resultSetInfo.ResultSetTable.Rows)
{
int num = int.Parse(dataRow[featureClassInfo.GetFeatureClass().FidFieldName].ToString());
string value = num.ToString();
System.Collections.Generic.KeyValuePair <int, string> item = new System.Collections.Generic.KeyValuePair <int, string>(num, value);
list.Add(item);
list2.Add(num);
}
}
}
finally
{
System.IDisposable disposable = enumerator as System.IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
if (featureClassInfo != null)
{
using (MergeDlg mergeDlg = new MergeDlg(list))
{
if (mergeDlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
if (System.Windows.Forms.DialogResult.No != XtraMessageBox.Show("模型合并不支持撤销操作，是否继续？", "提示", System.Windows.Forms.MessageBoxButtons.YesNo, System.Windows.Forms.MessageBoxIcon.Exclamation))
{
int fid = mergeDlg.Fid;
using (new WaitDialogForm("", "正在进行模型合并,请稍后..."))
{
IFeatureClass featureClass = featureClassInfo.GetFeatureClass();
string geometryFieldName = featureClassInfo.GetFeatureLayer().GeometryFieldName;
IModelPoint model = this.GetModel(featureClass, geometryFieldName, fid);
IResourceManager resourceManager = CommonUtils.Instance().GetCurrentFeatureDataset() as IResourceManager;
if (resourceManager != null)
{
if (!this.MergeModels(featureClass, geometryFieldName, list2.ToArray <int>(), resourceManager, ref model))
{
XtraMessageBox.Show("模型合并失败!");
}
else
{
if (list2.Remove(fid))
{
featureClass.Delete(new QueryFilterClass
{
IdsFilter = list2.ToArray <int>()
});
CommonUtils.Instance().Delete(featureClassInfo, list2.ToArray <int>());
app.Current3DMapControl.FeatureManager.DeleteFeatures(featureClass, list2.ToArray <int>());
}
app.Current3DMapControl.RefreshModel(CommonUtils.Instance().GetCurrentFeatureDataset(), model.ModelName);
IFdeCursor fdeCursor = featureClass.Update(new QueryFilterClass
{
IdsFilter = new int[]
{
fid
}
});
IRowBuffer rowBuffer = fdeCursor.NextRow();
if (rowBuffer != null)
{
int num2 = rowBuffer.FieldIndex(geometryFieldName);
if (num2 != -1)
{
rowBuffer.SetValue(num2, model);
}
fdeCursor.UpdateRow(rowBuffer);
System.Runtime.InteropServices.Marshal.ReleaseComObject(fdeCursor);
app.Current3DMapControl.FeatureManager.EditFeature(featureClass, rowBuffer);
}
//System.Runtime.InteropServices.Marshal.ReleaseComObject(featureClass);
}
}
}
}
}
}
}
}
catch (System.Runtime.InteropServices.COMException ex)
{
XtraMessageBox.Show(ex.Message);
}
catch (System.UnauthorizedAccessException var_23_389)
{
XtraMessageBox.Show("拒绝访问");
}
catch (System.Exception ex2)
{
XtraMessageBox.Show(ex2.Message);
}
finally
{
app.Current3DMapControl.ResumeRendering();
}
}
public override void Run(object sender, EventArgs e)
{
try
{
app = DF3DApplication.Application;
if (app == null || app.Current3DMapControl == null)
{
return;
}
this._geoFact = new GeometryFactory();
Map3DCommandManager.Push(this);
DF3DFeatureClass dffc = CommonUtils.Instance().CurEditLayer;
if (dffc != null)
{
this._facType = dffc.GetFacilityClassName();
_strGeometryFieldName = "";
if (this._facType == "PipeLine" || this._facType == "PipeNode" || this._facType == "PipeBuild" || this._facType == "PipeBuild1")
{
_strGeometryFieldName = "Shape";
}
else
{
IFeatureLayer fl = dffc.GetFeatureLayer();
if (fl != null)
{
_strGeometryFieldName = fl.GeometryFieldName;
}
}
if (!string.IsNullOrEmpty(_strGeometryFieldName))
{
IFeatureClass fc = dffc.GetFeatureClass();
if (fc != null)
{
IFieldInfoCollection fiCol = fc.GetFields();
int index = fiCol.IndexOf(_strGeometryFieldName);
if (index != -1)
{
IFieldInfo fi = fiCol.Get(index);
if (fi.GeometryDef != null)
{
this._geoType = fi.GeometryDef.GeometryColumnType;
}
}
}
switch (this._geoType)
{
case gviGeometryColumnType.gviGeometryColumnModelPoint:
//添加方式：1、鼠标添加；2、文件添加
FrmInsertModel dlg = new FrmInsertModel();
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
string filePath = dlg.FilePath;
string ext = Path.GetExtension(filePath);
if (File.Exists(filePath))
{
int insertType = dlg.InsertType;
if (insertType == 0 && ext.ToLower() == ".osg")
{
this._drawTool = DrawToolService.Instance.CreateDrawTool(DrawType._3DModel);
if (this._drawTool != null)
{
(this._drawTool as Draw3DModel).Set3DModelFilePath(filePath);
this._drawTool.OnStartDraw += new OnStartDraw(this.OnStartDraw);
this._drawTool.OnFinishedDraw += new OnFinishedDraw(this.OnFinishedDraw);
this._drawTool.Start();
}
}
else if (insertType == 1 && ext.ToLower() == ".xml")
{
}
}
}
break;
case gviGeometryColumnType.gviGeometryColumnPoint:
if (this._facType == "PipeNode")
{ // 添加附属设施或者管点
}
else
{ // 添加点
this._drawTool = DrawToolService.Instance.CreateDrawTool(DrawType.Point);
if (this._drawTool != null)
{
this._drawTool.OnStartDraw += new OnStartDraw(this.OnStartDraw);
this._drawTool.OnFinishedDraw += new OnFinishedDraw(this.OnFinishedDraw);
this._drawTool.Start();
}
}
break;
case gviGeometryColumnType.gviGeometryColumnPolyline:
if (this._facType == "PipeLine" || this._facType == "PipeBuild" || this._facType == "PipeBuild1")
{ // 选择管线或辅助样式
}
else
{ // 添加线
this._drawTool = DrawToolService.Instance.CreateDrawTool(DrawType.Polyline);
if (this._drawTool != null)
{
this._drawTool.OnStartDraw += new OnStartDraw(this.OnStartDraw);
this._drawTool.OnFinishedDraw += new OnFinishedDraw(this.OnFinishedDraw);
this._drawTool.Start();
}
}
break;
case gviGeometryColumnType.gviGeometryColumnPolygon:
if (this._facType == "PipeBuild" || this._facType == "PipeBuild1")
{ // 选择管线辅助样式
}
else
{ // 添加面
this._drawTool = DrawToolService.Instance.CreateDrawTool(DrawType.Polygon);
if (this._drawTool != null)
{
this._drawTool.OnStartDraw += new OnStartDraw(this.OnStartDraw);
this._drawTool.OnFinishedDraw += new OnFinishedDraw(this.OnFinishedDraw);
this._drawTool.Start();
}
}
break;
default:
return;
}
}
}
}
catch (Exception ex)
{
}
finally
{
}
}
private void OnFinishedDraw()
{
try
{
if (this._drawTool != null && this._drawTool.GetGeo() != null)
{
switch (this._drawTool.GeoType)
{
case DrawType.Point:
break;
case DrawType.Polyline:
break;
case DrawType.Circle:
break;
case DrawType.Rectangle:
break;
case DrawType.Polygon:
break;
default:
return;
}
IGeometry geo = this._drawTool.GetGeo();
if (geo == null)
{
return;
}
IGeometry geoBuffer = (geo as ITopologicalOperator2D).Buffer2D(Convert.ToDouble(this.seBufferDis.Value.ToString()), gviBufferStyle.gviBufferCapround);
if (geoBuffer == null)
{
return;
}
if (this._drawTool != null)
{
this._drawTool.OnStartDraw -= new OnStartDraw(this.OnStartDraw);
this._drawTool.OnFinishedDraw -= new OnFinishedDraw(this.OnFinishedDraw);
this._drawTool.Close();
this._drawTool.End();
}
this._3DControl.HighlightHelper.VisibleMask = 1;
this._3DControl.HighlightHelper.SetRegion(geoBuffer);
if (geoBuffer.GeometryType == gviGeometryType.gviGeometryPolygon)
{
this._rPolygon = this._3DControl.ObjectManager.CreateRenderPolygon(geoBuffer as IPolygon, this._surfaceSymbol, this._3DControl.ProjectTree.RootID);
if (this._3DControl.Terrain.IsRegistered && this._3DControl.Terrain.VisibleMask != gviViewportMask.gviViewNone)
{
(this._rPolygon as IRenderPolygon).HeightStyle = gviHeightStyle.gviHeightOnTerrain;
}
else
{
(this._rPolygon as IRenderPolygon).HeightStyle = gviHeightStyle.gviHeightAbsolute;
}
}
else if (geoBuffer.GeometryType == gviGeometryType.gviGeometryMultiPolygon)
{
this._rPolygon = this._3DControl.ObjectManager.CreateRenderMultiPolygon(geoBuffer as IMultiPolygon, this._surfaceSymbol, this._3DControl.ProjectTree.RootID);
if (this._3DControl.Terrain.IsRegistered && this._3DControl.Terrain.VisibleMask != gviViewportMask.gviViewNone)
{
(this._rPolygon as IRenderMultiPolygon).HeightStyle = gviHeightStyle.gviHeightOnTerrain;
}
else
{
(this._rPolygon as IRenderMultiPolygon).HeightStyle = gviHeightStyle.gviHeightAbsolute;
}
}
else
{
return;
}
if (this.cmbLayer.SelectedItem == null)
{
return;
}
ISpatialFilter filter = new SpatialFilter();
filter.Geometry = geoBuffer;
if (this.cmbSpatialRelation.Text == "包含")
{
filter.SpatialRel = gviSpatialRel.gviSpatialRelContains;
}
else
{
filter.SpatialRel = gviSpatialRel.gviSpatialRelIntersects;
}
DF3DFeatureClass dffc = this.cmbLayer.SelectedItem as DF3DFeatureClass;
IFeatureClass fc = dffc.GetFeatureClass();
if (fc == null)
{
return;
}
IFeatureLayer fl = dffc.GetFeatureLayer();
if (fl == null)
{
return;
}
filter.GeometryField = fl.GeometryFieldName;
int count = fc.GetCount(filter);
if (count == 0)
{
XtraMessageBox.Show("查询结果为空", "提示");
return;
}
WaitForm.Start("正在查询...", "请稍后");
this._uPanel = new UIDockPanel("查询结果", "查询结果", this.Location1, this._width, this._height);
this._dockPanel = FloatPanelManager.Instance.Add(ref this._uPanel, DockingStyle.Right);
this._dockPanel.Visibility = DockVisibility.Visible;
this._dockPanel.FloatSize = new System.Drawing.Size(this._width, this._height);
this._dockPanel.Width = this._width;
this._dockPanel.Height = this._height;
this._uc = new UCPropertyInfo();
this._uc.Init();
this._uc.Dock = System.Windows.Forms.DockStyle.Fill;
this._uPanel.RegisterEvent(new PanelClose(this.Close));
this._dockPanel.Controls.Add(this._uc);
this._uc.SetInfo(dffc, filter, count);
WaitForm.Stop();
}
}
catch (Exception ex)
{
}
}
private void AddRecord()
{
try
{
this.beforeRowBufferMap.Clear();
SelectCollection.Instance().Clear();
DF3DFeatureClass featureClassInfo = CommonUtils.Instance().CurEditLayer;
if (featureClassInfo == null)
{
return;
}
IFeatureClass fc = featureClassInfo.GetFeatureClass();
if (fc == null)
{
return;
}
IFeatureLayer fl = featureClassInfo.GetFeatureLayer();
if (fl == null)
{
return;
}
IFieldInfoCollection fields = fc.GetFields();
int indexGeo = fields.IndexOf(fl.GeometryFieldName);
if (indexGeo == -1)
{
return;
}
IFieldInfo fiGeo = fields.Get(indexGeo);
if (fiGeo == null || fiGeo.GeometryDef == null)
{
return;
}
IGeometry geo = this._drawTool.GetGeo();
if (geo.GeometryType != gviGeometryType.gviGeometryPolygon)
{
return;
}
IPolygon polygon = geo as IPolygon;
IPolygon geoOut = this._geoFact.CreateGeometry(gviGeometryType.gviGeometryPolygon, fiGeo.GeometryDef.VertexAttribute) as IPolygon;
for (int i = 0; i < polygon.ExteriorRing.PointCount; i++)
{
IPoint ptGet = polygon.ExteriorRing.GetPoint(i);
IPoint pttemp = ptGet.Clone2(fiGeo.GeometryDef.VertexAttribute) as IPoint;
if (fiGeo.GeometryDef.HasZ)
{
pttemp.SetCoords(ptGet.X, ptGet.Y, ptGet.Z, 0, 0);
}
else
{
pttemp.SetCoords(ptGet.X, ptGet.Y, 0, 0, 0);
}
geoOut.ExteriorRing.AppendPoint(pttemp);
}
IRowBufferCollection rowCol = new RowBufferCollection();
IRowBufferFactory fac = new RowBufferFactory();
IRowBuffer row = fac.CreateRowBuffer(fields);
row.SetValue(indexGeo, geoOut);
foreach (DataRow dr in this._dt.Rows)
{
IFieldInfo fi = dr["F"] as IFieldInfo;
if (fi == null)
{
continue;
}
string fn = fi.Name;
int index = fields.IndexOf(fn);
if (index != -1)
{
if (dr["FV"] == null)
{
row.SetNull(index);
}
else
{
string strobj = dr["FV"].ToString();
bool bRes = false;
switch (fi.FieldType)
{
case gviFieldType.gviFieldBlob:
case gviFieldType.gviFieldGeometry:
case gviFieldType.gviFieldUnknown:
break;
case gviFieldType.gviFieldFloat:
float f;
bRes = float.TryParse(strobj, out f);
if (bRes)
{
row.SetValue(index, f);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldDouble:
double d;
bRes = double.TryParse(strobj, out d);
if (bRes)
{
row.SetValue(index, d);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldFID:
case gviFieldType.gviFieldUUID:
case gviFieldType.gviFieldInt16:
Int16 i16;
bRes = Int16.TryParse(strobj, out i16);
if (bRes)
{
row.SetValue(index, i16);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldInt32:
Int32 i32;
bRes = Int32.TryParse(strobj, out i32);
if (bRes)
{
row.SetValue(index, i32);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldInt64:
Int64 i64;
bRes = Int64.TryParse(strobj, out i64);
if (bRes)
{
row.SetValue(index, i64);
}
else
{
row.SetNull(index);
}
break;;
case gviFieldType.gviFieldString:
row.SetValue(index, strobj);
break;
case gviFieldType.gviFieldDate:
DateTime dt;
bRes = DateTime.TryParse(strobj, out dt);
if (bRes)
{
row.SetValue(index, dt);
}
else
{
row.SetNull(index);
}
break;
default:
break;
}
}
}
}
rowCol.Add(row);
beforeRowBufferMap[featureClassInfo] = rowCol;
UpdateDatabase();
}
catch (Exception ex)
{
}
}
private void AddRecord()
{
try
{
this.beforeRowBufferMap.Clear();
SelectCollection.Instance().Clear();
if (reg == null || tc == null)
{
return;
}
FacStyleClass style = this.cmbStyle.EditValue as FacStyleClass;
if (style == null)
{
return;
}
SubClass sc = this.cmbClassify.EditValue as SubClass;
DF3DFeatureClass featureClassInfo = CommonUtils.Instance().CurEditLayer;
if (featureClassInfo == null)
{
return;
}
IFeatureClass fc = featureClassInfo.GetFeatureClass();
if (fc == null)
{
return;
}
IResourceManager manager = fc.FeatureDataSet as IResourceManager;
if (manager == null)
{
return;
}
IFeatureLayer fl = featureClassInfo.GetFeatureLayer();
if (fl == null)
{
return;
}
IFieldInfoCollection fields = fc.GetFields();
int indexOid = fields.IndexOf(fc.FidFieldName);
if (indexOid == -1)
{
return;
}
int mpindex = fields.IndexOf(fl.GeometryFieldName);
if (mpindex == -1)
{
return;
}
int indexShape = fields.IndexOf("Shape");
if (indexShape == -1)
{
return;
}
int indexFootPrint = fields.IndexOf("FootPrint");
if (indexFootPrint == -1)
{
return;
}
int indexStyleId = fields.IndexOf("StyleId");
if (indexStyleId == -1)
{
return;
}
int indexFacilityId = fields.IndexOf("FacilityId");
if (indexFacilityId == -1)
{
return;
}
IFieldInfo fiShape = fields.Get(indexShape);
if (fiShape == null || fiShape.GeometryDef == null)
{
return;
}
IGeometry geo = this._drawTool.GetGeo();
if (geo.GeometryType != gviGeometryType.gviGeometryPoint)
{
return;
}
IPoint pt = geo as IPoint;
IPoint geoOut = pt.Clone2(fiShape.GeometryDef.VertexAttribute) as IPoint;
if (fiShape.GeometryDef.HasZ)
{
geoOut.SetCoords(pt.X, pt.Y, pt.Z, 0, 0);
}
else
{
geoOut.SetCoords(pt.X, pt.Y, 0, 0, 0);
}
IQueryFilter filter = new QueryFilter();
filter.WhereClause = "1=1";
filter.ResultBeginIndex = 0;
filter.ResultLimit = 1;
filter.PostfixClause = "ORDER BY " + fc.FidFieldName + " desc";
IFdeCursor cursor = null;
cursor = fc.Search(filter, false);
IRowBuffer rowtemp = cursor.NextRow();
int oid = 0;
if (rowtemp != null)
{
oid = int.Parse(rowtemp.GetValue(indexOid).ToString());
}
if (cursor != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(cursor);
cursor = null;
}
IRowBufferFactory fac = new RowBufferFactory();
IRowBuffer row = fac.CreateRowBuffer(fields);
row.SetValue(indexOid, oid + 1);
row.SetValue(indexShape, geoOut);
row.SetValue(indexFootPrint, geoOut.Clone2(gviVertexAttribute.gviVertexAttributeNone));
row.SetValue(indexStyleId, style.ObjectId);
row.SetValue(indexFacilityId, BitConverter.ToString(ObjectIdGenerator.Generate()).Replace("-", string.Empty).ToLowerInvariant());
if (sc != null)
{
int indexClassify = fields.IndexOf(this._classifyName);
int indexGroupId = fields.IndexOf("GroupId");
if (indexClassify != -1 && indexGroupId != -1)
{
row.SetValue(indexClassify, sc.Name);
row.SetValue(indexGroupId, sc.GroupId);
}
}
foreach (DataRow dr in this._dt.Rows)
{
IFieldInfo fi = dr["F"] as IFieldInfo;
if (fi == null)
{
continue;
}
string fn = fi.Name;
int index = fields.IndexOf(fn);
if (index != -1)
{
if (dr["FV"] == null)
{
row.SetNull(index);
}
else
{
string strobj = dr["FV"].ToString();
bool bRes = false;
switch (fi.FieldType)
{
case gviFieldType.gviFieldBlob:
case gviFieldType.gviFieldGeometry:
case gviFieldType.gviFieldUnknown:
break;
case gviFieldType.gviFieldFloat:
float f;
bRes = float.TryParse(strobj, out f);
if (bRes)
{
row.SetValue(index, f);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldDouble:
double d;
bRes = double.TryParse(strobj, out d);
if (bRes)
{
row.SetValue(index, d);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldFID:
case gviFieldType.gviFieldUUID:
case gviFieldType.gviFieldInt16:
Int16 i16;
bRes = Int16.TryParse(strobj, out i16);
if (bRes)
{
row.SetValue(index, i16);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldInt32:
Int32 i32;
bRes = Int32.TryParse(strobj, out i32);
if (bRes)
{
row.SetValue(index, i32);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldInt64:
Int64 i64;
bRes = Int64.TryParse(strobj, out i64);
if (bRes)
{
row.SetValue(index, i64);
}
else
{
row.SetNull(index);
}
break;;
case gviFieldType.gviFieldString:
row.SetValue(index, strobj);
break;
case gviFieldType.gviFieldDate:
DateTime dt;
bRes = DateTime.TryParse(strobj, out dt);
if (bRes)
{
row.SetValue(index, dt);
}
else
{
row.SetNull(index);
}
break;
default:
break;
}
}
}
}
Fac plf = new PipeNodeFac(reg, style, row, tc);
IModelPoint mp = null;
IModel finemodel = null;
IModel simplemodel = null;
string name = "";
if (UCAuto3DCreate.RebuildModel(plf, style, out mp, out finemodel, out simplemodel, out name))
{
if (finemodel == null || mp == null)
{
return;
}
mp.ModelEnvelope = finemodel.Envelope;
row.SetValue(mpindex, mp);
//if (mc != null)
//{
// if (indexClassify != -1 && indexGroupid != -1)
// {
// }
//}
bool bRes = false;
if (!string.IsNullOrEmpty(mp.ModelName))
{
if (!manager.ModelExist(mp.ModelName))
{
if (manager.AddModel(mp.ModelName, finemodel, simplemodel))
{
bRes = true;
}
}
else
{
if (manager.UpdateModel(mp.ModelName, finemodel) && manager.UpdateSimplifiedModel(mp.ModelName, simplemodel))
{
bRes = true;
}
}
}
if (!bRes)
{
return;
}
IRowBufferCollection rowCol = new RowBufferCollection();
rowCol.Add(row);
beforeRowBufferMap[featureClassInfo] = rowCol;
UpdateDatabase();
app.Current3DMapControl.FeatureManager.RefreshFeatureClass(fc);
}
}
catch (Exception ex)
{
}
}
private void OnFinishedDraw()
{
if (this._drawTool != null && this._drawTool.GeoType == DrawType.Polygon && this._drawTool.GetGeo() != null)
{
try
{
WaitForm.Start("正在空间查询...", "请稍后");
List <MajorClass> listMCs = LogicDataStructureManage3D.Instance.GetAllMajorClass();
if (listMCs != null)
{
ISpatialFilter filter = new SpatialFilterClass();
filter.Geometry = this._drawTool.GetGeo();
filter.GeometryField = "FootPrint";
filter.SpatialRel = gviSpatialRel.gviSpatialRelContains;
Dictionary <MajorClass, List <IRowBuffer> > dict = new Dictionary <MajorClass, List <IRowBuffer> >();
foreach (MajorClass mc in listMCs)
{
IRowBuffer row = null;
IFdeCursor cursor = null;
try
{
string[] arrFc3DId = mc.Fc3D.Split(';');
if (arrFc3DId == null)
{
continue;
}
foreach (string fc3DId in arrFc3DId)
{
DF3DFeatureClass dffc = DF3DFeatureClassManager.Instance.GetFeatureClassByID(fc3DId);
if (dffc == null)
{
continue;
}
FacilityClass facc = dffc.GetFacilityClass();
IFeatureClass fc = dffc.GetFeatureClass();
IFeatureLayer fl = dffc.GetFeatureLayer();
if (fl == null || fc == null || facc == null || facc.Name != "PipeLine")
{
continue;
}
if (fl.VisibleMask == gviViewportMask.gviViewNone)
{
continue;
}
int count = fc.GetCount(filter);
if (count == 0)
{
break;
}
List <IRowBuffer> list = new List <IRowBuffer>();
cursor = fc.Search(filter, false);
while ((row = cursor.NextRow()) != null)
{
list.Add(row);
}
dict[mc] = list;
}
}
catch (Exception ex)
{
}
finally
{
if (row != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(row);
row = null;
}
if (cursor != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(cursor);
cursor = null;
}
}
}
WaitForm.Stop();
if (dict.Count == 0)
{
XtraMessageBox.Show("该区域内没有管线", "提示");
return;
}
FrmPipelineCross dlg = new FrmPipelineCross(dict);
dlg.Show();
}
}
catch (Exception ex)
{
WaitForm.Stop();
}
finally
{
}
}
}
private void AddRecord(IGeometry geo)
{
try
{
if (geo.GeometryType != gviGeometryType.gviGeometryModelPoint)
{
return;
}
this.beforeRowBufferMap.Clear();
SelectCollection.Instance().Clear();
DF3DFeatureClass featureClassInfo = CommonUtils.Instance().CurEditLayer;
if (featureClassInfo == null)
{
return;
}
IFeatureClass fc = featureClassInfo.GetFeatureClass();
if (fc == null)
{
return;
}
IFeatureDataSet fds = fc.FeatureDataSet;
if (fds == null)
{
return;
}
IFeatureLayer fl = featureClassInfo.GetFeatureLayer();
if (fl == null)
{
return;
}
IFieldInfoCollection fields = fc.GetFields();
int indexGeo = fields.IndexOf(fl.GeometryFieldName);
if (indexGeo == -1)
{
return;
}
IFieldInfo fiGeo = fields.Get(indexGeo);
if (fiGeo == null || fiGeo.GeometryDef == null)
{
return;
}
IModelPoint pt = geo as IModelPoint;
string mname = Path.GetFileNameWithoutExtension(pt.ModelName);
IEnvelope envelope = ImportOsg(fc, pt.ModelName);
if (envelope == null)
{
return;
}
IModelPoint geoOut = pt.Clone2(fiGeo.GeometryDef.VertexAttribute) as IModelPoint;
if (fiGeo.GeometryDef.HasZ)
{
geoOut.SetCoords(pt.X, pt.Y, pt.Z, 0, 0);
}
else
{
geoOut.SetCoords(pt.X, pt.Y, 0, 0, 0);
}
geoOut.ModelName = mname;
geoOut.ModelEnvelope = new EnvelopeClass
{
MinX = envelope.MinX,
MaxX = envelope.MaxX,
MinY = envelope.MinY,
MaxY = envelope.MaxY,
MinZ = envelope.MinZ,
MaxZ = envelope.MaxZ
};
IRowBufferCollection rowCol = new RowBufferCollection();
IRowBufferFactory fac = new RowBufferFactory();
IRowBuffer row = fac.CreateRowBuffer(fields);
row.SetValue(indexGeo, geoOut);
foreach (DataRow dr in this._dt.Rows)
{
IFieldInfo fi = dr["F"] as IFieldInfo;
if (fi == null)
{
continue;
}
string fn = fi.Name;
int index = fields.IndexOf(fn);
if (index != -1)
{
if (dr["FV"] == null)
{
row.SetNull(index);
}
else
{
string strobj = dr["FV"].ToString();
bool bRes = false;
switch (fi.FieldType)
{
case gviFieldType.gviFieldBlob:
case gviFieldType.gviFieldGeometry:
case gviFieldType.gviFieldUnknown:
break;
case gviFieldType.gviFieldFloat:
float f;
bRes = float.TryParse(strobj, out f);
if (bRes)
{
row.SetValue(index, f);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldDouble:
double d;
bRes = double.TryParse(strobj, out d);
if (bRes)
{
row.SetValue(index, d);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldFID:
case gviFieldType.gviFieldUUID:
case gviFieldType.gviFieldInt16:
Int16 i16;
bRes = Int16.TryParse(strobj, out i16);
if (bRes)
{
row.SetValue(index, i16);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldInt32:
Int32 i32;
bRes = Int32.TryParse(strobj, out i32);
if (bRes)
{
row.SetValue(index, i32);
}
else
{
row.SetNull(index);
}
break;
case gviFieldType.gviFieldInt64:
Int64 i64;
bRes = Int64.TryParse(strobj, out i64);
if (bRes)
{
row.SetValue(index, i64);
}
else
{
row.SetNull(index);
}
break;;
case gviFieldType.gviFieldString:
row.SetValue(index, strobj);
break;
case gviFieldType.gviFieldDate:
DateTime dt;
bRes = DateTime.TryParse(strobj, out dt);
if (bRes)
{
row.SetValue(index, dt);
}
else
{
row.SetNull(index);
}
break;
default:
break;
}
}
}
}
rowCol.Add(row);
beforeRowBufferMap[featureClassInfo] = rowCol;
UpdateDatabase();
Clear();
(this._drawTool as Draw3DModel).Set3DModelFilePath(this.beFilePath.Text);
}
catch (Exception ex)
{
}
}
public override bool Contains(object key)
{
DF3DFeatureClass cfg = key as DF3DFeatureClass;
return(cfg != null && (this.Keys.Cast <DF3DFeatureClass>().Any((DF3DFeatureClass info) => cfg.GetFeatureLayer().Guid == info.GetFeatureLayer().Guid) || base.Contains(key)));
}
private void DeleteFeatures(object param)
{
IFeatureClass featureClass = null;
IDataSource dataSource = null;
IFeatureDataSet featureDataSet = null;
try
{
EditParameters editParameters = (EditParameters)param;
DF3DFeatureClass featureClassInfo = DF3DFeatureClassManager.Instance.GetFeatureClassByID(editParameters.featureClassGuid);
string fcName = editParameters.fcName;
if (!string.IsNullOrEmpty(fcName) && featureClassInfo != null)
{
dataSource = ((IDataSourceFactory) new DataSourceFactoryClass()).OpenDataSourceByString(editParameters.connectionInfo);
featureDataSet = dataSource.OpenFeatureDataset(editParameters.datasetName);
int nTotalCount = editParameters.nTotalCount;
int num = 0;
featureClass = featureDataSet.OpenFeatureClass(fcName);
string geometryFieldName = featureClassInfo.GetFeatureLayer().GeometryFieldName;
featureClass.SetRenderIndexEnabled(geometryFieldName, false);
if (featureClass.HasTemporal() && CommonUtils.Instance().EnableTemproalEdit)
{
System.DateTime temproalTime = editParameters.TemproalTime;
TemporalFilter temporalFilter = new TemporalFilterClass();
temporalFilter.AddSubField(featureClass.FidFieldName);
temporalFilter.IdsFilter = editParameters.fidList;
ITemporalManager temporalManager = featureClass.TemporalManager;
ITemporalCursor temporalCursor = temporalManager.Search(temporalFilter);
while (temporalCursor.MoveNext())
{
temporalCursor.Dead(temproalTime);
num++;
string userState = string.Format(StringParser.Parse("${res:feature_progress_delete}"), num, nTotalCount);
int percentProgress = num * 100 / nTotalCount;
this._bgWorker.ReportProgress(percentProgress, userState);
}
System.Runtime.InteropServices.Marshal.ReleaseComObject(temporalCursor);
System.Runtime.InteropServices.Marshal.ReleaseComObject(temporalManager);
}
else
{
featureClass.FeatureDataSet.DataSource.StartEditing();
IFdeCursor fdeCursor = featureClass.Update(new QueryFilterClass
{
IdsFilter = editParameters.fidList
});
while (fdeCursor.NextRow() != null && !this._bgWorker.CancellationPending)
{
fdeCursor.DeleteRow();
num++;
string userState2 = string.Format(StringParser.Parse("${res:feature_progress_delete}"), num, nTotalCount);
int percentProgress2 = num * 100 / nTotalCount;
this._bgWorker.ReportProgress(percentProgress2, userState2);
}
System.Runtime.InteropServices.Marshal.ReleaseComObject(fdeCursor);
featureClass.FeatureDataSet.DataSource.StopEditing(true);
}
if (this._progressDlg.Created)
{
string userState3 = StringParser.Parse("${res:feature_progress_updateindex}");
int percentProgress3 = num * 100 / nTotalCount;
this._bgWorker.ReportProgress(percentProgress3, userState3);
}
featureClass.SetRenderIndexEnabled(geometryFieldName, true);
featureClass.RebuildRenderIndex(geometryFieldName, gviRenderIndexRebuildType.gviRenderIndexRebuildWithData);
object[] args = new object[]
{
featureClassInfo,
editParameters.fidList
};
//System.IAsyncResult asyncResult = MainFrmService.ResultSetPanel.BeginInvoke(this._deleteSelection, args);
//MainFrmService.ResultSetPanel.EndInvoke(asyncResult);
}
}
catch (System.Exception)
{
if (featureClass != null)
{
featureClass.FeatureDataSet.DataSource.StopEditing(false);
}
}
finally
{
//if (featureClass != null)
//{
// System.Runtime.InteropServices.Marshal.ReleaseComObject(featureClass);
// featureClass = null;
//}
if (featureDataSet != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(featureDataSet);
featureDataSet = null;
}
if (dataSource != null)
{
System.Runtime.InteropServices.Marshal.ReleaseComObject(dataSource);
dataSource = null;
}
}
}
private void InsertSelection(IObjectClass oc, IRowBufferCollection rows)
{
//FeatureClassInfo featureClassInfo = WorkSpaceServices.Instance().GetFeatureClassInfo(oc.Name, true);
DF3DFeatureClass featureClassInfo = DF3DFeatureClassManager.Instance.GetFeatureClassByID(oc.GuidString);
if (featureClassInfo == null)
{
return;
}
if (oc.Type == gviDataSetType.gviDataSetFeatureClassTable)
{
lock (SelectCollection.Instance().FeatureClassInfoMap)
{
ResultSetInfo resultSetInfo = SelectCollection.Instance().FeatureClassInfoMap[featureClassInfo] as ResultSetInfo;
if (resultSetInfo == null)
{
object[] args = new object[]
{
oc,
//featureClassInfo.GeometryFieldName
featureClassInfo.GetFeatureLayer().GeometryFieldName
};
//DataTable dt = MainFrmService.MainFrm.Invoke(this._CreaDataTable, args) as DataTable;
//resultSetInfo = new ResultSetInfo(dt, SelectCollection.Instance().GetOIDList(rows));
//resultSetInfo.TotalCount = 0;
//SelectCollection.Instance().FeatureClassInfoMap[featureClassInfo] = resultSetInfo;
//MainFrmService.MainFrm.Invoke(this._notifySelection);
}
//DataTable resultSetTable = resultSetInfo.ResultSetTable;
//for (int i = 0; i < rows.Count; i++)
//{
// this._nCurIndex++;
// string userState = string.Format(StringParser.Parse("${res:feature_progress_finished}"), this._nCurIndex, this._nTotalCount);
// int percentProgress = this._nCurIndex * 100 / this._nTotalCount;
// this._bgWorker.ReportProgress(percentProgress, userState);
// object[] args2 = new object[]
// {
// oc,
// resultSetTable,
// rows.Get(i)
// };
// int num = -1;
// int.TryParse(MainFrmService.MainFrm.Invoke(this._InsertRecord, args2).ToString(), out num);
// if (resultSetInfo.OidList == null)
// {
// resultSetInfo.OidList = new System.Collections.Generic.List<int>();
// }
// if (num != -1 && !resultSetInfo.OidList.Contains(num))
// {
// resultSetInfo.OidList.Add(num);
// }
//}
//if (resultSetInfo.OidList.Count<int>() > 0)
//{
// RenderControlServices.Instance().AxRenderControl.FeatureManager.HighlightFeatures(oc as IFeatureClass, resultSetInfo.OidList.ToArray(), 4294901860u);
//}
//resultSetInfo.TotalCount += rows.Count;
//object[] args3 = new object[]
//{
// featureClassInfo.FeatureLayerGuidString,
// resultSetInfo.TotalCount,
// resultSetInfo.ResultSetTable.Rows.Count
//};
//MainFrmService.MainFrm.Invoke(this._recordsChanged, args3);
//HashMap hashMap = MainFrmService.MainFrm.Invoke(this._GetRowbufferMap) as HashMap;
//MainFrmService.MainFrm.Invoke(this._setEditorPositionHandel, new object[]
//{
// hashMap
//});
}
}
}
