public FrmTableView(IDbClass dbClass, ITableClass table, string parentTitle = null)
{
InitializeComponent();
_dbClass = dbClass;
_table = table;
this.Text += "【" + _table.TableName + "】- " + parentTitle;
}
private void ProcessTableClass(ITableClass tc, IQueryFilter filter)
{
/*
* if (tc != null)
* {
*
* IRowCursor cursor = tc.Search(filter) as IRowCursor;
* if (cursor == null) return;
*
* RowTable ftab = new RowTable(cursor, tc.Fields);
* ftab.Fill(200);
* _table = ftab.Table;
*
* while (ftab.hasMore)
* {
* if (_cancelTracker != null && !_cancelTracker.Continue) break;
* if (Progress != null) Progress();
* ftab.Fill(200);
* }
*
* cursor.Release();
* }
* if (ThreadFinished != null) ThreadFinished();
* */
}
public FrmTableView(IDbClass dbClass,ITableClass table,string parentTitle=null)
{
InitializeComponent();
_dbClass = dbClass;
_table = table;
this.Text += "【" + _table.TableName + "】- " + parentTitle;
}
async private void FormDataTable_Load(object sender, System.EventArgs e)
{
var value = _tableClass;
_maxNewSelectedRows = 200;
_selectedRowIndices = new List <int>();
grid.DataSource = null;
_tableClass = value;
if (_tableClass == null)
{
return;
}
grid.DefaultCellStyle.BackColor = Color.White;
gView.Framework.Data.QueryFilter filter = new gView.Framework.Data.QueryFilter();
foreach (IField field in _tableClass.Fields.ToEnumerable())
{
if (field.type == FieldType.binary || field.type == FieldType.Shape)
{
continue;
}
filter.AddField(field.name);
}
//filter.SubFields="*";
ICursor cursor = await _tableClass.Search(filter);
if (cursor is IFeatureCursor)
{
_result = new FeatureTable((IFeatureCursor)cursor, _tableClass.Fields, _tableClass);
}
else if (cursor is IRowCursor)
{
_result = new RowTable((IRowCursor)cursor, _tableClass.Fields);
}
else
{
return;
}
_result.RowsAddedToTable -= new RowsAddedToTableEvent(RowsAddedToTable);
progress1.Minimum = 0;
progress1.Visible = true;
progress1.Value = 0;
await _result.Fill(progress1.Maximum = 200);
_result.RowsAddedToTable += new RowsAddedToTableEvent(RowsAddedToTable);
_viewTable = null; // in PrepareDataView neu anlegen...
PrepareDataView(_result.Table);
cmbShow.SelectedIndex = 0; // hier wird auch MarkSelected durchgeführt
progress1.Visible = false;
}
async static public Task <string> ToXml(ITableClass fc, IQueryFilter filter)
{
if (filter is IBufferQueryFilter)
{
filter = await BufferQueryFilter.ConvertToSpatialFilter((IBufferQueryFilter)filter);
}
MemoryStream ms = new MemoryStream();
StreamWriter sw = new StreamWriter(ms, Encoding.UTF8);
sw.WriteLine("<Filter>");
if (filter is IRowIDFilter)
{
if (fc.IDFieldName == String.Empty)
{
CreateRowIDFilter(fc, filter as IRowIDFilter, sw);
}
else
{
ParseInWhereClause(((IRowIDFilter)filter).RowIDWhereClause, sw);
}
}
else if (filter is IQueryFilter)
{
if (filter.WhereClause.ToLower().Contains(" in ("))
{
ParseInWhereClause(filter.WhereClause, sw);
}
else
{
ParseWhereClause(filter.WhereClause, sw);
}
}
sw.WriteLine("</Filter>");
sw.Flush();
ms.Position = 0;
byte[] bytes = new byte[ms.Length];
ms.Read(bytes, 0, (int)ms.Length);
sw.Close();
string ret = Encoding.UTF8.GetString(bytes).Trim();
// ret = @"<ogc:Filter>
// <ogc:PropertyIsLike wildCard=""%"" singleChar=""?"" escape=""ESC"">
// <ogc:PropertyName>
// item_plz
// </ogc:PropertyName>
// <ogc:Literal>
// 53111
// </ogc:Literal>
// </ogc:PropertyIsLike>
//</ogc:Filter>";
return(ret);
}
async private void contextItem_ImportFields_Click(object sender, EventArgs e)
{
var alterTable = await GetAlterTable();
if (alterTable == null)
{
MessageBox.Show("Change properties is not implemented for this feature...");
return;
}
var tableClass = await _exObject?.GetInstanceAsync() as ITableClass;
if (tableClass == null)
{
return;
}
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
filters.Add(new OpenFeatureclassFilter());
ExplorerDialog dlg = new ExplorerDialog("Open Featureclass", filters, true);
dlg.MulitSelection = false;
if (dlg.ShowDialog() == DialogResult.OK &&
dlg.ExplorerObjects != null &&
dlg.ExplorerObjects.Count == 1)
{
var dlgTableClass = await dlg.ExplorerObjects[0].GetInstanceAsync() as ITableClass;
if (dlgTableClass != null)
{
ITableClass tcFrom = dlgTableClass;
ITableClass tcTo = tableClass;
FormSelectFields selDlg = new FormSelectFields(tcFrom, tcTo);
if (selDlg.ShowDialog() == DialogResult.OK)
{
foreach (IField field in selDlg.SelectedFields)
{
if (!await alterTable.AlterTable(_exObject.Name, null, new Field(field)))
{
MessageBox.Show("ERROR :" + ((alterTable is IDatabase) ? ((IDatabase)alterTable).LastErrorMessage : ""));
break;
}
}
await this.OnShow();
}
}
}
}
private static void CreateRowIDFilter(ITableClass fc, IRowIDFilter filter, StreamWriter sw)
{
if (fc == null || filter == null || sw == null)
{
return;
}
string fcName = fc.Name;
foreach (int id in filter.IDs)
{
//sw.WriteLine("<ogc:GmlObjectId gml:id=\"" + fcName + "." + id.ToString() + "\" />");
sw.WriteLine("<FeatureId fid=\"" + fcName + "." + id.ToString() + "\" />");
}
}
async public override Task <int?> GetNextInsertRowId(ITableClass table)
{
if (RepoProvider == null)
{
throw new Exception("Repository not initialized");
}
var sdeLayer = RepoProvider.LayerFromTableClass(table);
if (sdeLayer == null)
{
throw new Exception("Sde layer not found: " + table?.Name);
}
return(await RepoProvider.GetInsertRowId(sdeLayer));
}
async static public Task <FormQueryBuilder> CreateAsync(ITableClass tc)
{
var dlg = new FormQueryBuilder();
dlg._tc = tc;
if (dlg._tc == null)
{
return(dlg);
}
gView.Framework.Data.QueryFilter filter = new gView.Framework.Data.QueryFilter();
filter.SubFields = "*";
using (ICursor cursor = await dlg._tc.Search(filter))
{
if (cursor is IFeatureCursor)
{
dlg._table = new FeatureTable((IFeatureCursor)cursor, dlg._tc.Fields, dlg._tc);
}
else if (cursor is IRowCursor)
{
dlg._table = new RowTable((IRowCursor)cursor, dlg._tc.Fields);
}
else
{
return(dlg);
}
await dlg._table.Fill(2000);
}
dlg.cmbMethod.SelectedIndex = 0;
foreach (IField field in dlg._tc.Fields.ToEnumerable())
{
if (field.type == FieldType.binary ||
field.type == FieldType.Shape)
{
continue;
}
dlg.lstFields.Items.Add(Field.WhereClauseFieldName(field.name));
}
return(dlg);
}
private void contextItem_ImportFields_Click(object sender, EventArgs e)
{
if (AlterTable == null)
{
MessageBox.Show("Change properties is not implemented for this feature...");
return;
}
if (_exObject == null || !(_exObject.Object is ITableClass))
{
return;
}
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
filters.Add(new OpenFeatureclassFilter());
ExplorerDialog dlg = new ExplorerDialog("Open Featureclass", filters, true);
dlg.MulitSelection = false;
if (dlg.ShowDialog() == DialogResult.OK &&
dlg.ExplorerObjects != null &&
dlg.ExplorerObjects.Count == 1 &&
dlg.ExplorerObjects[0].Object is ITableClass)
{
ITableClass tcFrom = dlg.ExplorerObjects[0].Object as ITableClass;
ITableClass tcTo = _exObject.Object as ITableClass;
FormSelectFields selDlg = new FormSelectFields(tcFrom, tcTo);
if (selDlg.ShowDialog() == DialogResult.OK)
{
foreach (IField field in selDlg.SelectedFields)
{
if (!AlterTable.AlterTable(_exObject.Name, null, new Field(field)))
{
MessageBox.Show("ERROR :" + ((AlterTable is IDatabase) ? ((IDatabase)AlterTable).lastErrorMsg : ""));
break;
}
}
this.OnShow();
}
}
}
public FormQueryBuilder(ITableClass tc)
{
_tc = tc;
InitializeComponent();
if (_tc == null)
{
return;
}
gView.Framework.Data.QueryFilter filter = new gView.Framework.Data.QueryFilter();
filter.SubFields = "*";
using (ICursor cursor = _tc.Search(filter))
{
if (cursor is IFeatureCursor)
{
_table = new FeatureTable((IFeatureCursor)cursor, _tc.Fields, _tc);
}
else if (cursor is IRowCursor)
{
_table = new RowTable((IRowCursor)cursor, _tc.Fields);
}
else
{
return;
}
_table.Fill(2000);
}
cmbMethod.SelectedIndex = 0;
foreach (IField field in _tc.Fields.ToEnumerable())
{
if (field.type == FieldType.binary ||
field.type == FieldType.Shape)
{
continue;
}
lstFields.Items.Add(Field.WhereClauseFieldName(field.name));
}
}
public FormSelectFields(ITableClass tcFrom, ITableClass tcTo)
{
InitializeComponent();
if (tcFrom == null || tcTo == null ||
tcFrom.Fields == null || tcTo.Fields == null)
{
return;
}
foreach (IField field in tcFrom.Fields.ToEnumerable())
{
if (field == null ||
field.type == FieldType.ID || field.type == FieldType.Shape ||
tcTo.FindField(field.name) != null)
{
continue;
}
lstBox.Items.Add(new FieldItem(field), true);
}
}
static public IQueryFilter FromXml(ITableClass fc, XmlNode filter /*, string nsName*/)
{
XmlNamespaceManager ns = null;
if (filter.NamespaceURI != String.Empty)
{
ns = new XmlNamespaceManager(filter.OwnerDocument.NameTable);
}
StringBuilder whereClause = new StringBuilder();
IQueryFilter newFilter = null;
ParseWFSFilter(fc, filter, "", ns, whereClause, ref newFilter);
if (newFilter == null)
{
newFilter = new QueryFilter();
}
newFilter.WhereClause = RemoveOuterBrackets(whereClause.ToString());
return(newFilter);
}
async public Task <bool> BeforeUpdate(ITableClass tClass)
{
if (!(tClass is IFeatureClass))
{
return(false);
}
IFeatureClass fc = (IFeatureClass)tClass;
foreach (IField field in fc.Fields.ToEnumerable())
{
if (field is IAutoField)
{
if (!await((IAutoField)field).OnUpdate(fc, this as IFeature))
{
return(false);
}
}
}
return(true);
}
public bool BeforeUpdate(ITableClass tClass)
{
if (!(tClass is IFeatureClass))
{
return(false);
}
IFeatureClass fc = (IFeatureClass)tClass;
foreach (IField field in fc.Fields)
{
if (field is IAutoField)
{
if (!((IAutoField)field).OnUpdate(fc, this as IFeature))
{
return(false);
}
}
}
return(true);
}
public bool BeforeInsert(ITableClass tClass)
{
if (!(tClass is IFeatureClass))
{
return(false);
}
IFeatureClass fc = (IFeatureClass)tClass;
foreach (IField field in fc.Fields.ToEnumerable())
{
if (field is IAutoField)
{
if (!((IAutoField)field).OnInsert(fc, this as IFeature))
{
return(false);
}
}
}
return(true);
}
public FormDataTable2(IDatasetElement dsElement)
{
InitializeComponent();
_tableClass = null;
if (dsElement is IFeatureLayer)
{
_tableClass = ((IFeatureLayer)dsElement).FeatureClass;
}
else if (dsElement is ITableLayer)
{
_tableClass = ((ITableLayer)dsElement).TableClass;
}
_dsElement = dsElement;
cmbShow.SelectedIndex = 0;
if (_dsElement is IFeatureSelection)
{
((IFeatureSelection)_dsElement).FeatureSelectionChanged -= new FeatureSelectionChangedEvent(FeatureSelectionChanged);
((IFeatureSelection)_dsElement).FeatureSelectionChanged += new FeatureSelectionChangedEvent(FeatureSelectionChanged);
}
}
private void sourceTree_EventSource(object sender, EventSourceTreeArgs e)
{
switch (e.EventSourceType)
{
case EventSourceType.Open:
{
ITableClass table = e.SourceObject as ITableClass;
if (table != null)
{
FrmTableView tableView = new FrmTableView(_dbClass, table, _dbConnectConfigure.GetSimpleText());
FrmMain.Main.ShowOrActiveForm(tableView);
}
else
{
string text = "查看";
switch (e.TreeNodeType)
{
case SourceTree.TreeNodeType.TRIGGER:
text += "触发器";
break;
case SourceTree.TreeNodeType.SEQUENCE:
text += "序列";
break;
case SourceTree.TreeNodeType.FUNCTION:
text += "函数";
break;
case SourceTree.TreeNodeType.PROCEDURE:
text += "过程";
break;
case SourceTree.TreeNodeType.JAVASOURCE:
text += "JAVA资源";
break;
case SourceTree.TreeNodeType.JOB:
text += "事务";
break;
case SourceTree.TreeNodeType.VIEW:
text += "视图";
break;
default:
break;
}
if (e.SourceObject is IGetAttribute)
{
text += ":" + ((IGetAttribute)e.SourceObject).Name;
}
FrmNormalView normalView = new FrmNormalView(_dbClass, e.SourceObject, text);
FrmMain.Main.ShowOrActiveForm(normalView);
}
}
break;
case EventSourceType.Select:
break;
case EventSourceType.Insert:
break;
case EventSourceType.Update:
break;
case EventSourceType.Delete:
break;
default:
break;
}
}
virtual public Task <int?> GetNextInsertRowId(ITableClass table)
{
return(null);
}
public SdeFeatureCursor(SdeDataset dataset, ITableClass tc, IQueryFilter filter)
: base((tc is IFeatureClass) && ((IFeatureClass)tc).SpatialReference != null ?
((IFeatureClass)tc).SpatialReference : filter.ContextLayerDefaultSpatialReference,
(filter != null) ? filter.FeatureSpatialReference : null)
{
try
{
if (filter != null && !filter.SubFields.Contains("*"))
{
filter.AddField(tc.IDFieldName, false);
}
filter.fieldPrefix = tc.Name + ".";
filter.fieldPostfix = "";
if (filter is ISpatialFilter &&
(((ISpatialFilter)filter).SpatialRelation != spatialRelation.SpatialRelationMapEnvelopeIntersects))
{
if (tc is IFeatureClass)
{
filter.AddField(((IFeatureClass)tc).ShapeFieldName);
}
_spatialFilter = (ISpatialFilter)filter;
}
Int32 err_no = 0;
_dataset = dataset;
if (_dataset == null)
{
return;
}
//_connection = _dataset.AllocConnection();
_connection = new ArcSdeConnection(dataset.ConnectionString);
if (!_connection.Open(this._dataset))
{
return;
}
_queryInfo = new SdeQueryInfo(_connection, tc, filter);
if (_queryInfo.ErrorMessage != "")
{
Dispose();
return;
}
//if (Wrapper10.SE_stream_create(_connection.SeConnection, ref _stream) != 0)
//{
// Dispose();
// return;
//}
//_connection.ResetStream();
_stream = _connection.CreateStream();
// SE_stream_set_state sollte auch aufgerufen werden (siehe mapsde.c von UMN)
if (Wrapper10.SE_stream_set_state(
_stream.SeStream,
CONST.SE_DEFAULT_STATE_ID,
CONST.SE_DEFAULT_STATE_ID,
CONST.SE_STATE_DIFF_NOCHECK) != 0)
{
Dispose();
return;
}
if ((err_no = Wrapper10.SE_stream_query_with_info(_stream.SeStream, _queryInfo.SeQueryInfo)) != 0)
{
Dispose();
return;
}
if (_queryInfo.IsSpatial)
{
SE_FILTER se_filter = _queryInfo.Filter_Shape;
if ((err_no = Wrapper10.SE_stream_set_spatial_constraints(_stream.SeStream, CONST.SE_SPATIAL_FIRST, false, 1, ref se_filter)) != 0)
{
_errMsg = Wrapper10.GetErrorMsg(_connection.SeConnection, err_no);
Dispose();
return;
}
}
else
{
/*
* SE_FILTER se_filter = _queryInfo.Filter_Id;
* if (Wrapper10.SE_stream_set_spatial_constraints(_stream, CONST.SE_SPATIAL_FIRST, false, 1, ref se_filter) != 0)
* {
* Release();
* return;
* }
* */
}
if (Wrapper10.SE_stream_execute(_stream.SeStream) != 0)
{
Dispose();
return;
}
_queryFields = _queryInfo.QueryFields;
_queryInfo.Dispose();
_queryInfo = null;
}
catch (Exception ex)
{
_errMsg = ex.Message + "\n" + ex.StackTrace;
Dispose();
}
}
private static string ParseWFSFilterNode(ITableClass fc, XmlNode node, XmlNamespaceManager ns)
{
//if(fc==null)
// throw new ArgumentException("ParseWFSFilterNode: FeatureClass is null...");
if (node == null)
{
return(String.Empty);
}
string op = String.Empty;
switch (node.Name)
{
case "PropertyIsEqualTo":
op = "=";
break;
case "PropertyIsLike":
op = " like ";
break;
case "PropertyIsGreaterThan":
op = ">";
break;
case "PropertyIsGreaterThanOrEqualTo":
op = ">=";
break;
case "PropertyIsLessThan":
op = "<";
break;
case "PropertyIsLessThanOrEqualTo":
op = "<=";
break;
case "PropertyIsNotEqualTo":
op = "<>";
break;
default:
throw new Exception("Unknown operation: " + node.Name + ". Xml is case sensitive.");
}
XmlNodeList propertyName = (ns != null) ? node.SelectNodes("OGC:PropertyName", ns) : node.SelectNodes("PropertyName");
if (propertyName.Count > 1)
{
throw new Exception("More than one PropertyName in Property: " + node.OuterXml);
}
if (propertyName.Count == 0)
{
throw new Exception("No PropertyName in Property: " + node.OuterXml);
}
XmlNodeList Literal = (ns != null) ? node.SelectNodes("OGC:Literal", ns) : node.SelectNodes("Literal");
if (Literal.Count > 1)
{
throw new Exception("More than one Literal in Property: " + node.OuterXml);
}
if (Literal.Count == 0)
{
throw new Exception("No Literal in Property: " + node.OuterXml);
}
string fieldname = propertyName[0].InnerText;
string fieldvalue = Literal[0].InnerText;
if (fc != null)
{
IField field = fc.FindField(fieldname);
if (field == null)
{
throw new Exception("Type " + fc.Name + " do not has field " + fieldname);
}
switch (field.type)
{
case FieldType.String:
fieldvalue = "'" + fieldvalue + "'";
break;
case FieldType.Date:
fieldvalue = "'" + fieldvalue + "'";
break;
}
}
return(fieldname + op + fieldvalue);
}
public override bool HasManagedRowIds(ITableClass table)
{
return(false);
}
public SdeLayer LayerFromTableClass(ITableClass tableClass)
{
return(this.Layers?.Where(l => (l.Owner + "." + l.TableName).Equals(tableClass?.Name, StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault());
}
public FillTableThread(ITableClass Class, ICancelTracker cancelTracker)
{
_class = Class;
_cancelTracker = cancelTracker;
}
public static bool ModifyFilter(IServiceMap map, ITableClass tClass, IQueryFilter filter)
{
if (filter == null || tClass == null)
{
return(false);
}
string subFields = filter.SubFields;
if (subFields != "*")
{
filter.SubFields = String.Empty;
foreach (string subField in subFields.Split(' '))
{
string fname = subField;
if (subFields.StartsWith(filter.fieldPrefix) &&
subFields.EndsWith(filter.fieldPostfix))
{
fname = fname.Substring(filter.fieldPrefix.Length, fname.Length - filter.fieldPrefix.Length - filter.fieldPostfix.Length);
}
if (tClass.Fields != null)
{
if (tClass.FindField(fname) != null ||
(tClass is IFeatureClass && ((IFeatureClass)tClass).ShapeFieldName == fname))
{
filter.AddField(fname);
}
}
}
}
try
{
XmlDocument xmlFilter = new XmlDocument();
string xml = Xml.ToXml(tClass, filter);
xmlFilter.LoadXml(xml);
XmlNodeList propertyNames = xmlFilter.SelectNodes("//PropertyName");
foreach (XmlNode propertyName in propertyNames)
{
if (propertyName.InnerText == MergedObjectIDName)
{
XmlNode literal = propertyName.ParentNode.SelectSingleNode("Literal");
if (literal == null)
{
return(false);
}
long mergedID;
if (!long.TryParse(literal.InnerText, out mergedID))
{
return(false);
}
int classID = GetClassID(map, tClass), propertyClassID = GetClassID(mergedID);
if (classID != propertyClassID)
{
propertyName.ParentNode.ParentNode.RemoveChild(propertyName.ParentNode);
continue;
}
propertyName.InnerText = tClass.IDFieldName;
literal.InnerText = GetObjectID(mergedID).ToString();
}
else if (tClass.Fields.FindField(propertyName.InnerText) == null)
{
propertyName.ParentNode.ParentNode.RemoveChild(
propertyName.ParentNode);
}
}
// keine Properties übgrig geblieben sind -> nicht abfraten...
if (propertyNames.Count > 0 && xmlFilter.SelectNodes("//PropertyName").Count == 0)
{
return(false);
}
IQueryFilter f = Xml.FromXml(tClass, xmlFilter.SelectSingleNode("Filter"));
// Prüfen, ob vom Filter noch was übrig bleibt...
if (!String.IsNullOrEmpty(filter.WhereClause) &&
String.IsNullOrEmpty(f.WhereClause))
{
return(false);
}
filter.WhereClause = f.WhereClause;
}
catch { return(false); }
return(true);
}
private void FormChartWizard_Load(object sender, EventArgs e)
{
#region Tab Chart Type
foreach (gvChart.gvChartType chartType in gvChart.ChartTypes)
{
lstChartTypes.Items.Add(chartType);
}
lstChartTypes.SelectedItem = 0;
Series ser1 = new Series("Serie 1");
ser1.Points.AddXY("A", 10);
ser1.Points.AddXY("B", 6);
ser1.Points.AddXY("C", 8);
ser1.Points.AddXY("D", 12);
ser1.Points.AddXY("E", 3);
ser1.Color = Color.Red;
ser1.ChartArea = "Area1";
Series ser2 = new Series("Serie 2");
ser2.Points.AddXY("A", 5);
ser2.Points.AddXY("B", 3);
ser2.Points.AddXY("C", 7);
ser2.Points.AddXY("D", 8);
ser2.Points.AddXY("E", 6);
ser2.Color = Color.Blue;
ser2.ChartArea = "Area1";
_gvChart.Series.Add(ser1);
_gvChart.Series.Add(ser2);
_gvChart.Refresh();
#endregion
#region Tab Data
ITableClass tc = (ITableClass)_layer.Class;
foreach (IField field in _layer.Fields)
{
if (field.type == FieldType.biginteger ||
field.type == FieldType.Double ||
field.type == FieldType.Float ||
field.type == FieldType.integer ||
field.type == FieldType.smallinteger)
{
lstSeries.Items.Add(new FieldItem()
{
Field = field
});
}
if (field.type != FieldType.binary &&
field.type != FieldType.GEOGRAPHY &&
field.type != FieldType.GEOMETRY &&
field.type != FieldType.Shape)
{
cmbDataFields.Items.Add(new FieldItem()
{
Field = field
});
}
}
if (cmbDataFields.Items.Count > 0)
{
cmbDataFields.SelectedIndex = 0;
}
#region Filter
//All Features
//Selected Features
//Features in actual extent
cmbFeatures.Items.Add(new ExportMethodItem("All Features", new QueryFilter()));
if (_layer is IFeatureSelection &&
((IFeatureSelection)_layer).SelectionSet != null &&
((IFeatureSelection)_layer).SelectionSet.Count > 0)
{
ISelectionSet selectionSet = ((IFeatureSelection)_layer).SelectionSet;
IQueryFilter selFilter = null;
if (selectionSet is IIDSelectionSet)
{
selFilter = new RowIDFilter(tc.IDFieldName, ((IIDSelectionSet)selectionSet).IDs);
}
else if (selectionSet is IGlobalIDSelectionSet)
{
selFilter = new GlobalRowIDFilter(tc.IDFieldName, ((IGlobalIDSelectionSet)selectionSet).IDs);
}
else if (selectionSet is IQueryFilteredSelectionSet)
{
selFilter = ((IQueryFilteredSelectionSet)selectionSet).QueryFilter.Clone() as IQueryFilter;
}
if (selFilter != null)
{
selFilter.SubFields = "*";
ExportMethodItem item = new ExportMethodItem("Selected Features", selFilter);
cmbFeatures.Items.Add(item);
cmbFeatures.SelectedItem = item;
}
}
if (_display != null && _display.Envelope != null)
{
SpatialFilter dispFilter = new SpatialFilter();
dispFilter.SubFields = "*";
dispFilter.FilterSpatialReference = _display.SpatialReference;
dispFilter.Geometry = _display.Envelope;
dispFilter.SpatialRelation = spatialRelation.SpatialRelationIntersects;
cmbFeatures.Items.Add(new ExportMethodItem("Features in actual extent", dispFilter));
}
if (cmbFeatures.SelectedIndex == -1)
{
cmbFeatures.SelectedIndex = 0;
}
#endregion
#endregion
}
public Task <bool> BeforeDelete(ITableClass tClass)
{
return(Task.FromResult <bool>(true));
}
public FormRotationType(SymbolRotation symbolRotation, ITableClass tableClass)
{
//
// Erforderlich für die Windows Form-Designerunterstützung
//
InitializeComponent();
_symbolRotation = symbolRotation;
string fieldname = "";
if (_symbolRotation != null)
{
fieldname = _symbolRotation.RotationFieldName;
switch (_symbolRotation.RotationType)
{
case RotationType.geographic:
radioButton1.Checked = true;
break;
case RotationType.aritmetic:
radioButton2.Checked = true;
break;
}
switch (_symbolRotation.RotationUnit)
{
case RotationUnit.rad:
cmbUnit.SelectedIndex = 0;
break;
case RotationUnit.deg:
cmbUnit.SelectedIndex = 1;
break;
case RotationUnit.gon:
cmbUnit.SelectedIndex = 2;
break;
}
}
if (tableClass != null)
{
cmbFields.Items.Add(new FieldItem(null));
foreach (IField field in tableClass.Fields)
{
if (field.type == FieldType.Double ||
field.type == FieldType.Float ||
field.type == FieldType.integer ||
field.type == FieldType.smallinteger ||
field.type == FieldType.biginteger)
{
FieldItem item = new FieldItem(field);
cmbFields.Items.Add(item);
if (field.name == fieldname)
{
cmbFields.SelectedItem = item;
}
}
}
if (cmbFields.SelectedItem == null)
{
cmbFields.SelectedItem = cmbFields.Items[0];
}
}
else
{
cmbFields.Visible = false;
}
}
private static void ParseWFSFilter(ITableClass fc, XmlNode parentNode, string LogicalOperator, XmlNamespaceManager ns, StringBuilder sb, ref IQueryFilter newFilter)
{
if (parentNode == null)
{
return;
}
foreach (XmlNode child in parentNode.ChildNodes)
{
XmlNode gmlNode = null;
switch (child.Name)
{
case "And":
StringBuilder sb1 = new StringBuilder();
ParseWFSFilter(fc, child, "AND", ns, sb1, ref newFilter);
AppendClause(LogicalOperator, "(" + sb1.ToString() + ")", sb);
//sb.Append("(" + sb1.ToString() + ")");
break;
case "Or":
StringBuilder sb2 = new StringBuilder();
ParseWFSFilter(fc, child, "OR", ns, sb2, ref newFilter);
AppendClause(LogicalOperator, "(" + sb2.ToString() + ")", sb);
//sb.Append("(" + sb2.ToString() + ")");
break;
case "Not":
StringBuilder sb3 = new StringBuilder();
ParseWFSFilter(fc, child, "NOT", ns, sb3, ref newFilter);
AppendClause(LogicalOperator, "(" + sb3.ToString() + ")", sb);
//sb.Append("(" + sb3.ToString() + ")");
break;
case "BBOX":
if (newFilter != null)
{
throw new Exception("Invalid or corrupt Filter!!!");
}
newFilter = new SpatialFilter();
((ISpatialFilter)newFilter).SpatialRelation = spatialRelation.SpatialRelationEnvelopeIntersects;
gmlNode = (ns != null) ? child.SelectSingleNode("GML:*", ns) : child.ChildNodes[0];
break;
case "Intersects":
if (newFilter != null)
{
throw new Exception("Invalid or corrupt Filter!!!");
}
newFilter = new SpatialFilter();
((ISpatialFilter)newFilter).SpatialRelation = spatialRelation.SpatialRelationIntersects;
gmlNode = (ns != null) ? child.SelectSingleNode("GML:*", ns) : child.ChildNodes[0];
break;
case "Within":
if (newFilter != null)
{
throw new Exception("Invalid or corrupt Filter!!!");
}
newFilter = new SpatialFilter();
((ISpatialFilter)newFilter).SpatialRelation = spatialRelation.SpatialRelationContains;
gmlNode = (ns != null) ? child.SelectSingleNode("GML:*", ns) : child.ChildNodes[0];
break;
case "Contains":
if (newFilter != null)
{
throw new Exception("Invalid or corrupt Filter!!!");
}
newFilter = new SpatialFilter();
((ISpatialFilter)newFilter).SpatialRelation = spatialRelation.SpatialRelationContains;
gmlNode = (ns != null) ? child.SelectSingleNode("GML:*", ns) : child.ChildNodes[0];
break;
default:
string clause = ParseWFSFilterNode(fc, child, ns);
AppendClause(LogicalOperator, clause, sb);
break;
}
if (gmlNode != null && newFilter is ISpatialFilter)
{
//((ISpatialFilter)newFilter).Geometry = GeometryTranslator.GML2Geometry(gmlNode.OuterXml);
//if (((ISpatialFilter)newFilter).Geometry == null)
// throw new Exception("Unknown GML Geometry...");
//if (gmlNode.Attributes["srsName"] != null)
// ((ISpatialFilter)newFilter).SpatialReference = SpatialReference.FromID(gmlNode.Attributes["srsName"].Value);
}
}
}
public TableClassBindingSource(ITableClass Class)
{
_class = Class;
if (_class == null) return;
cursor = Class.Search(new QueryFilter());
}
public SdeQueryInfo(ArcSdeConnection connection, ITableClass tc, IQueryFilter filter)
{
if (tc == null)
{
return;
}
try
{
if (filter is ISpatialFilter && ((ISpatialFilter)filter).Geometry != null && tc is IFeatureClass && tc.Dataset is SdeDataset)
{
SE_ENVELOPE maxExtent = new SE_ENVELOPE();
SE_COORDREF coordRef = ((SdeDataset)tc.Dataset).GetSeCoordRef(connection, tc.Name, ((IFeatureClass)tc).ShapeFieldName, ref maxExtent);
if (((SdeDataset)tc.Dataset).lastErrorMsg != "")
{
return;
}
_isSpatial = true;
_err_no = Wrapper92.SE_shape_create(coordRef, ref _shape);
((SdeDataset)tc.Dataset).FreeSeCoordRef(coordRef);
if (_err_no != 0)
{
return;
}
//IEnvelope env = ((ISpatialFilter)filter).Geometry.Envelope;
//SE_ENVELOPE seEnvelope = new SE_ENVELOPE();
//seEnvelope.minx = Math.Max(env.minx, maxExtent.minx);
//seEnvelope.miny = Math.Max(env.miny, maxExtent.miny);
//seEnvelope.maxx = Math.Min(env.maxx, maxExtent.maxx);
//seEnvelope.maxy = Math.Min(env.maxy, maxExtent.maxy);
//if (seEnvelope.minx == seEnvelope.maxx && seEnvelope.miny == seEnvelope.maxy)
//{
// /* fudge a rectangle so we have a valid one for generate_rectangle */
// /* FIXME: use the real shape for the query and set the filter_type
// to be an appropriate type */
// seEnvelope.minx = seEnvelope.minx - 0.001;
// seEnvelope.maxx = seEnvelope.maxx + 0.001;
// seEnvelope.miny = seEnvelope.miny - 0.001;
// seEnvelope.maxy = seEnvelope.maxy + 0.001;
//}
//_err_no = Wrapper92.SE_shape_generate_rectangle(ref seEnvelope, _shape);
_err_no = gView.SDEWrapper.Functions.SE_GenerateGeometry(_shape, ((ISpatialFilter)filter).Geometry, maxExtent);
if (_err_no != 0)
{
return;
}
_seFilter.shape = _shape;
/* set spatial constraint column and table */
_seFilter.table = tc.Name.PadRight(CONST.SE_QUALIFIED_TABLE_NAME, '\0');;
_seFilter.column = ((IFeatureClass)tc).ShapeFieldName.PadRight(CONST.SE_MAX_COLUMN_LEN, '\0');
/* set a couple of other spatial constraint properties */
_seFilter.method = (((ISpatialFilter)filter).SpatialRelation == spatialRelation.SpatialRelationEnvelopeIntersects) ? CONST.SM_ENVP_BY_GRID /*CONST.SM_AI*/ : CONST.SM_AI;
_seFilter.filter_type = CONST.SE_SHAPE_FILTER;
_seFilter.truth = true; // True;
}
_err_no = Wrapper92.SE_queryinfo_create(ref _queryInfo);
if (_err_no != 0)
{
return;
}
_err_no = Wrapper92.SE_queryinfo_set_tables(_queryInfo, 1, new string[] { tc.Name }, null);
if (_err_no != 0)
{
return;
}
string [] fields;
if (filter.SubFields == "" || filter.SubFields == "*" || filter.SubFields == null)
{
StringBuilder subFields = new StringBuilder();
foreach (IField field in tc.Fields.ToEnumerable())
{
if (subFields.Length != 0)
{
subFields.Append(" ");
}
subFields.Append(tc.Name + "." + field.name);
_queryFields.Add(field);
}
fields = subFields.ToString().Split(' ');
}
else
{
fields = filter.SubFields.Split(' ');
foreach (string fieldname in fields)
{
string fname = fieldname;
if (fieldname.ToLower().IndexOf("distinct(") == 0)
{
fname = fieldname.Substring(9, fieldname.IndexOf(")") - 9);
}
IField field = tc.FindField(fname);
if (field == null)
{
_errMsg = "Can't get Field " + fname;
Cleanup();
return;
}
_queryFields.Add(field);
}
}
_err_no = Wrapper92.SE_queryinfo_set_columns(_queryInfo, fields.Length, fields);
if (_err_no != 0)
{
return;
}
string where = "";
if (filter != null)
{
if (filter is IRowIDFilter)
{
where = ((IRowIDFilter)filter).RowIDWhereClause;
}
else
{
where = filter.WhereClause;
}
}
if (where != "")
{
_err_no = Wrapper92.SE_queryinfo_set_where_clause(_queryInfo, where);
if (_err_no != 0)
{
return;
}
}
_err_no = Wrapper92.SE_queryinfo_set_query_type(_queryInfo, CONST.SE_QUERYTYPE_JSFA);
if (_err_no != 0)
{
return;
}
}
catch (Exception ex)
{
_errMsg = "SeQueryInfo:" + ex.Message + "\n" + ex.StackTrace;
_err_no = -1;
}
finally
{
if (_err_no != 0)
{
_errMsg = Wrapper92.GetErrorMsg(new SE_CONNECTION(), _err_no);
Cleanup();
}
}
}
