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();
}
}
}
}
async private void btnSelect_Click(object sender, EventArgs e)
{
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
filters.Add(new OpenFeatureDatasetFilter());
ExplorerDialog exDlg = new ExplorerDialog("Target Feature Dataset",
filters,
true);
if (exDlg.ShowDialog() == DialogResult.OK &&
exDlg.ExplorerObjects.Count == 1)
{
IExplorerObject parentObject = exDlg.ExplorerObjects[0];
var instance = await parentObject.GetInstanceAsync();
if (instance is IFeatureDataset &&
((IDataset)instance).Database is IFeatureUpdater)
{
_dataset = (IFeatureDataset)instance;
}
else
{
MessageBox.Show("Can't determine target featureclass!");
return;
}
txtDatasetName.Text = _dataset.Database.ToString();
txtDatasetLocation.Text = parentObject.FullName;
}
}
async public override Task <bool> Match(IExplorerObject exObject)
{
bool match = await base.Match(exObject);
// Grouplayer nicht...
if (exObject is IExplorerParentObject)
{
return(false);
}
var instance = await exObject?.GetInstanceAsync();
if (match && instance is ITOCElement && _geomType != geometryType.Unknown)
{
ITOCElement tocElement = instance as ITOCElement;
if (tocElement.Layers != null)
{
foreach (ILayer layer in tocElement.Layers)
{
if (layer is IFeatureLayer && ((IFeatureLayer)layer).FeatureClass != null)
{
return(((IFeatureLayer)layer).FeatureClass.GeometryType == _geomType);
}
}
}
}
//if (match && _geomType != geometryType.Unknown && exObject.Object is IFeatureLayer && ((IFeatureLayer)exObject.Object).FeatureClass != null)
//{
// return ((IFeatureLayer)exObject.Object).FeatureClass.GeometryType == _geomType;
//}
return(match);
}
async public override Task <bool> Match(IExplorerObject exObject)
{
bool match = await base.Match(exObject);
var instatnce = await exObject.GetInstanceAsync();
if (match && _geomType != geometryType.Unknown && instatnce is IFeatureLayer && ((IFeatureLayer)instatnce).FeatureClass != null)
{
return(((IFeatureLayer)instatnce).FeatureClass.GeometryType == _geomType);
}
return(match);
}
async public Task <bool> OnShow()
{
listView1.Items.Clear();
var instance = await _exObject.GetInstanceAsync();
if (!(instance is IFeatureClass))
{
return(false);
}
IFeatureClass fc = (IFeatureClass)instance;
if (fc.Fields == null)
{
return(false);
}
foreach (IField field in fc.Fields.ToEnumerable())
{
int iIndex = (field is IAutoField) ? 5 : 0;
switch (field.type)
{
case FieldType.ID:
iIndex = 4;
break;
case FieldType.Shape:
switch (fc.GeometryType)
{
case geometryType.Point:
case geometryType.Multipoint:
iIndex = 1;
break;
case geometryType.Polyline:
iIndex = 2;
break;
case geometryType.Envelope:
case geometryType.Polygon:
iIndex = 3;
break;
}
break;
}
listView1.Items.Add(new FieldListViewItem(new Field(field), iIndex));
}
return(true);
}
async private void btnImport_Click(object sender, EventArgs e)
{
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
filters.Add(new OpenDataFilter());
filters.Add(new OpenSpatialReferenceFilter());
ExplorerDialog dlg = new ExplorerDialog("Import Spatial Reference", filters, true);
dlg.MulitSelection = false;
if (dlg.ShowDialog() == DialogResult.OK && dlg.ExplorerObjects.Count == 1)
{
IExplorerObject exObject = dlg.ExplorerObjects[0];
var instatnce = await exObject?.GetInstanceAsync();
if (instatnce is IFeatureDataset)
{
_sRef = await((IFeatureDataset)instatnce).GetSpatialReference();
}
else if (instatnce is IRasterDataset)
{
_sRef = await((IRasterDataset)instatnce).GetSpatialReference();
}
else if (instatnce is IFeatureClass)
{
_sRef = ((IFeatureClass)instatnce).SpatialReference;
}
else if (instatnce is IRasterClass)
{
_sRef = ((IRasterClass)instatnce).SpatialReference;
}
else if (instatnce is IWebServiceClass)
{
_sRef = ((IWebServiceClass)instatnce).SpatialReference;
}
else if (instatnce is ISpatialReference)
{
_sRef = instatnce as ISpatialReference;
}
else
{
MessageBox.Show("Can't import spatial reference from data object...");
return;
}
MakeGUI();
}
}
async private Task RefreshList()
{
//if (listView.InvokeRequired)
//{
// RefreshListCallback d = new RefreshListCallback(RefreshList);
// this.BeginInvoke(d);
//}
//else
{
CancelRefreshList();
listView.Items.Clear();
_itemCollection.Clear();
if (_exObject == null)
{
return;
}
var instatnce = await _exObject.GetInstanceAsync();
if (instatnce is SqlFDBImageCatalogClass)
{
SqlFDBImageCatalogClass layer = (SqlFDBImageCatalogClass)instatnce;
_cancelWorker = false;
_gui_worker.RunWorkerAsync(await layer.ImageList());
}
else if (instatnce is IRasterCatalogClass)
{
IRasterCatalogClass layer = (IRasterCatalogClass)instatnce;
_cancelWorker = false;
//_gui_worker.RunWorkerAsync(layer.ImageList);
//
// Wirft eine Fehler beim Lesen, wenn List in einem
// Workerthread ausgeführt wird...
// funzt nur bei SQL Server!!
//
await worker_DoWork(_gui_worker, new DoWorkEventArgs(await layer.ImageList()));
}
else if (instatnce is pgImageCatalogClass)
{
pgImageCatalogClass layer = (pgImageCatalogClass)instatnce;
_cancelWorker = false;
_gui_worker.RunWorkerAsync(await layer.ImageList());
}
else if (instatnce is SQLiteFDBImageCatalogClass)
{
SQLiteFDBImageCatalogClass layer = (SQLiteFDBImageCatalogClass)instatnce;
_cancelWorker = false;
_gui_worker.RunWorkerAsync(await layer.ImageList());
}
}
}
async public Task <IExplorerObject> CreateExplorerObject(IExplorerObject parentExObject)
{
if (!CanCreate(parentExObject))
{
return(null);
}
var instance = await parentExObject.GetInstanceAsync();
if (!(instance is IFeatureDataset) || !(((IDataset)instance).Database is SQLiteFDB))
{
return(null);
}
SQLiteFDB fdb = ((IDataset)instance).Database as SQLiteFDB;
FormNewFeatureclass dlg = await FormNewFeatureclass.Create(instance as IFeatureDataset);
if (dlg.ShowDialog() != DialogResult.OK)
{
return(null);
}
IGeometryDef gDef = dlg.GeometryDef;
int FCID = await fdb.CreateFeatureClass(
parentExObject.Name,
dlg.FeatureclassName,
gDef,
dlg.Fields);
if (FCID < 0)
{
MessageBox.Show("ERROR: " + fdb.LastErrorMessage);
return(null);
}
ISpatialIndexDef sIndexDef = await fdb.SpatialIndexDef(parentExObject.Name);
await fdb.SetSpatialIndexBounds(dlg.FeatureclassName, "BinaryTree2", dlg.SpatialIndexExtents, 0.55, 200, dlg.SpatialIndexLevels);
IDatasetElement element = await((IFeatureDataset)instance).Element(dlg.FeatureclassName);
return(new SQLiteFDBFeatureClassExplorerObject(
parentExObject as SQLiteFDBDatasetExplorerObject,
_filename,
parentExObject.Name,
element));
}
async public override Task <bool> Match(IExplorerObject exObject)
{
if (exObject == null)
{
return(false);
}
var instance = await exObject.GetInstanceAsync();
if (instance is IDataset &&
((IDataset)instance).Database is IFeatureUpdater)
{
return(true);
}
return(false);
}
async public Task <bool> OnShow()
{
OnHide();
if (_exObject == null)
{
return(false);
}
var instance = await _exObject.GetInstanceAsync();
if (instance is ITableClass && _table != null)
{
_table.TableClass = (ITableClass)instance;
_table.StartWorkerThread();
}
return(true);
}
async public Task <bool> ShowWith(IExplorerObject exObject)
{
if (exObject == null)
{
return(false);
}
if (TypeHelper.Match(exObject.ObjectType, typeof(gView.DataSources.Fdb.MSSql.SqlFDBImageCatalogClass)))
{
return(true);
}
if (TypeHelper.Match(exObject.ObjectType, typeof(gView.DataSources.Fdb.PostgreSql.pgImageCatalogClass)))
{
return(true);
}
if (TypeHelper.Match(exObject.ObjectType, typeof(gView.DataSources.Fdb.SQLite.SQLiteFDBImageCatalogClass)))
{
return(true);
}
var instance = await exObject?.GetInstanceAsync();
if (instance is gView.DataSources.Fdb.MSSql.SqlFDBImageCatalogClass)
{
return(true);
}
if (instance is gView.DataSources.Fdb.PostgreSql.pgImageCatalogClass)
{
return(true);
}
if (instance is gView.DataSources.Fdb.SQLite.SQLiteFDBImageCatalogClass)
{
return(true);
}
return(false);
}
async void _checkinMenuItem_Click(object sender, EventArgs e)
{
//if (_contextItem is ExplorerObjectListViewItem && listView.SelectedItems.Count == 1 && _contextItem == listView.SelectedItems[0])
if (_contextObject != null)
{
IExplorerObject exObject = _contextObject; // _contextItem.ExplorerObject;
var exObjectInstance = await exObject?.GetInstanceAsync();
if (exObjectInstance is IFeatureClass &&
((IFeatureClass)exObjectInstance).Dataset != null)
{
IFeatureDatabase fdb = ((IFeatureClass)exObjectInstance).Dataset.Database as IFeatureDatabase;
if (fdb is IFeatureDatabaseReplication)
{
ReplicationUI.ShowCheckinDialog((IFeatureClass)exObjectInstance);
}
}
_contextObject = null;
}
}
async private void btnSelect_Click(object sender, EventArgs e)
{
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
filters.Add(new OpenFeatureDatasetFilter());
ExplorerDialog exDlg = new ExplorerDialog("New Target Featureclass",
SaveFeatureClassFilters.AllFilters,
false);
if (exDlg.ShowDialog() == DialogResult.OK &&
exDlg.ExplorerObjects.Count == 1)
{
IExplorerObject parentObject = exDlg.ExplorerObjects[0];
var instance = await parentObject.GetInstanceAsync();
if (instance is IFeatureDataset &&
((IDataset)instance).Database is IFeatureUpdater)
{
_dataset = (IFeatureDataset)instance;
}
else if (exDlg.SelectedExplorerDialogFilter.FilterObject is IFeatureDataset &&
((IDataset)exDlg.SelectedExplorerDialogFilter.FilterObject).Database is IFileFeatureDatabase)
{
IFileFeatureDatabase fileDB = (IFileFeatureDatabase)((IFeatureDataset)exDlg.SelectedExplorerDialogFilter.FilterObject).Database;
_dataset = await fileDB.GetDataset(parentObject.FullName);
}
else
{
MessageBox.Show("Can't determine target featureclass!");
return;
}
txtDatasetName.Text = _dataset.Database.ToString();
txtDatasetLocation.Text = parentObject.FullName;
txtTargetClass.Text = _listViewItem.TargetName = exDlg.TargetName;
}
btnNext.Enabled = exDlg.TargetName != String.Empty;
}
async public override Task <bool> Match(IExplorerObject exObject)
{
if (exObject == null)
{
return(false);
}
var instatnce = await exObject.GetInstanceAsync();
if (instatnce is IDatasetElement)
{
return(_aData.ProcessAble((IDatasetElement)instatnce));
}
if (instatnce is IClass)
{
DatasetElement element = new DatasetElement((IClass)instatnce);
return(_aData.ProcessAble(element));
}
return(false);
}
async void _metadataMenuItem_Click(object sender, EventArgs e)
{
//if (_contextItem is ExplorerObjectListViewItem)
if (_contextObject != null)
{
IExplorerObject exObject = _contextObject; // ((ExplorerObjectListViewItem)_contextItem).ExplorerObject;
if (exObject is IMetadata)
{
XmlStream xmlStream = new XmlStream(String.Empty);
((IMetadata)exObject).ReadMetadata(xmlStream);
var exObjectInstance = await exObject.GetInstanceAsync();
FormMetadata dlg = new FormMetadata(xmlStream, exObjectInstance);
if (dlg.ShowDialog() == DialogResult.OK)
{
await((IMetadata)exObject).WriteMetadata(await dlg.GetStream());
}
}
_contextObject = null;
}
}
async public Task <bool> OnEvent(object element, object dataset)
{
if (!(element is IFeatureLayer))
{
MessageBox.Show("Item is not a featurelayer");
return(true);
}
if (((IFeatureLayer)element).FeatureClass == null)
{
MessageBox.Show("Item has not a valid featureclass!");
return(true);
}
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
filters.Add(new OpenRendererFilter(((IFeatureLayer)element).FeatureClass.GeometryType));
ExplorerDialog dlg = new ExplorerDialog("Open Featurelayer...", filters, true);
dlg.MulitSelection = false;
if (dlg.ShowDialog() == DialogResult.OK)
{
IExplorerObject exObject = dlg.ExplorerObjects[0];
var instatnce = await exObject?.GetInstanceAsync();
if (!(instatnce is ITOCElement))
{
return(true);
}
IFeatureLayer source = ((ITOCElement)instatnce).Layers[0] as IFeatureLayer;
if (source == null)
{
return(true);
}
IFeatureLayer dest = (IFeatureLayer)element;
Dialogs.FormImportRenderers dlg2 = new Dialogs.FormImportRenderers();
if (dlg2.ShowDialog() == DialogResult.OK)
{
if (dlg2.FeatureRenderer)
{
dest.FeatureRenderer = source.FeatureRenderer;
}
if (dlg2.LabelRenderer)
{
dest.LabelRenderer = source.LabelRenderer;
}
if (dlg2.SelectionRenderer)
{
dest.SelectionRenderer = source.SelectionRenderer;
}
if (dlg2.RenderScales)
{
dest.MinimumScale = source.MinimumScale;
dest.MaximumScale = source.MaximumScale;
if (dlg2.FeatureRenderer)
{
dest.MaxRefScaleFactor = source.MaxRefScaleFactor;
}
}
if (dlg2.LabelScales)
{
dest.MinimumLabelScale = source.MinimumLabelScale;
dest.MaximumLabelScale = source.MaximumLabelScale;
if (dlg2.LabelRenderer)
{
dest.MaxLabelRefScaleFactor = source.MaxLabelRefScaleFactor;
}
}
if (dlg2.FilterQuery)
{
dest.FilterQuery = source.FilterQuery;
}
}
}
return(true);
}
async private Task InvokeSetExplorerObject()
{
_exObjectInvokeRequired = false;
mapView1.CancelDrawing(DrawPhase.All);
foreach (IDatasetElement element in _map.MapElements)
{
_map.RemoveLayer(element as ILayer);
}
if (_exObject != null)
{
var instance = await _exObject.GetInstanceAsync();
if (instance is IFeatureClass && ((IFeatureClass)instance).Envelope != null)
{
mapView1.Map = _map;
_map.AddLayer(LayerFactory.Create(instance as IClass));
_map.Display.Limit = ((IFeatureClass)instance).Envelope;
_map.Display.ZoomTo(((IFeatureClass)instance).Envelope);
}
else if (instance is IRasterClass && ((IRasterClass)instance).Polygon != null)
{
mapView1.Map = _map;
_map.AddLayer(LayerFactory.Create(instance as IClass));
_map.Display.Limit = ((IRasterClass)instance).Polygon.Envelope;
_map.Display.ZoomTo(((IRasterClass)instance).Polygon.Envelope);
}
else if (instance is IWebServiceClass && ((IWebServiceClass)instance).Envelope != null)
{
mapView1.Map = _map;
_map.AddLayer(LayerFactory.Create(instance as IClass));
_map.Display.Limit = ((IWebServiceClass)instance).Envelope;
_map.Display.ZoomTo(((IWebServiceClass)instance).Envelope);
}
else if (instance is IFeatureDataset)
{
mapView1.Map = _map;
IFeatureDataset dataset = (IFeatureDataset)instance;
foreach (IDatasetElement element in await dataset.Elements())
{
ILayer layer = LayerFactory.Create(element.Class) as ILayer;
if (layer == null)
{
continue;
}
_map.AddLayer(layer);
}
_map.Display.Limit = await dataset.Envelope();
_map.Display.ZoomTo(await dataset.Envelope());
}
else if (instance is Map)
{
Map map = (Map)instance;
map.NewBitmap -= InvokeNewBitmapCreated;
map.DoRefreshMapView -= InvokeDoRefreshMapView;
map.NewBitmap += InvokeNewBitmapCreated;
map.DoRefreshMapView += InvokeDoRefreshMapView;
mapView1.Map = (Map)instance;
}
}
}
async private Task Script(DragEventArgs e)
{
try
{
if (_exAppl == null)
{
return;
}
if (e.Data == null)
{
return;
}
string[] data = (string[])e.Data.GetData(DataFormats.FileDrop);
if (data == null || data.Length == 0)
{
return;
}
StringBuilder sb = new StringBuilder();
foreach (string filename in data)
{
DirectoryInfo di = new DirectoryInfo(filename);
var instance = await _exObject?.GetInstanceAsync();
if (instance is SqlFDBImageCatalogClass)
{
SqlFDBImageCatalogClass layer = (SqlFDBImageCatalogClass)instance;
if (layer._fdb == null)
{
return;
}
if (di.Exists)
{
sb.Append("\r\nCreateRasterCatalog -connectionstring \"" + layer._fdb.ConnectionString + "\" -ds \"" + layer.Name + "\" -root \"" + filename + "\" -managed");
}
else
{
//gView.Raster.File.RasterFileClass rLayer = new gView.Raster.File.RasterFileClass(null, filename);
//if (!rLayer.isValid) continue;
RasterFileDataset rDataset = new RasterFileDataset();
IRasterLayer rLayer = rDataset.AddRasterFile(filename);
if (rLayer != null)
{
sb.Append("\r\nCreateRasterCatalog -connectionstring \"" + layer._fdb.ConnectionString + "\" -ds \"" + layer.Name + "\" -append \"" + filename + "\" -managed");
}
}
}
else if (instance is IRasterCatalogClass)
{
IRasterCatalogClass layer = (IRasterCatalogClass)instance;
if (layer.Dataset == null)
{
return;
}
if (di.Exists)
{
sb.Append("\r\nCreateRasterCatalog -mdb \"" + ConfigTextStream.ExtractValue(layer.Dataset.ConnectionString, "mdb") + "\" -ds \"" + layer.Name + "\" -root \"" + filename + "\" -managed");
}
else
{
//gView.Raster.File.RasterFileClass rLayer = new gView.Raster.File.RasterFileClass(null, filename);
//if (!rLayer.isValid) continue;
RasterFileDataset rDataset = new RasterFileDataset();
IRasterLayer rLayer = rDataset.AddRasterFile(filename);
if (rLayer != null)
{
sb.Append("\r\nCreateRasterCatalog -mdb \"" + ConfigTextStream.ExtractValue(layer.Dataset.ConnectionString, "mdb") + "\" -ds \"" + layer.Name + "\" -append \"" + filename + "\" -managed");
}
}
}
}
if (sb.ToString() != "")
{
sb.Append(" -recalcspatialindex\r\n");
await _exAppl.ExecuteBatch(sb.ToString(), new ExplorerExecuteBatchCallback(this.RefreshList));
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
}
}
async private Task <ContextMenuStrip> BuildContextMenu(IExplorerObject exObject, List <IExplorerObject> context, bool emptyContentsClick)
{
if (_strip != null && _strip.Visible == true)
{
_strip.Close();
}
_strip = contextStrip;
for (int i = _strip.Items.Count - 1; i >= _contextItemCount; i--)
{
_strip.Items.RemoveAt(i);
}
toolStripMenuItemNew.DropDownItems.Clear();
PlugInManager compMan = new PlugInManager();
foreach (var compType in compMan.GetPlugins(Plugins.Type.IExplorerObject))
{
IExplorerObject ex = compMan.CreateInstance <IExplorerObject>(compType);
if (ex is IExplorerObjectCreatable)
{
if (!((IExplorerObjectCreatable)ex).CanCreate(_exObject))
{
continue;
}
ToolStripItem createNewItem = new CreateNewToolStripItem(ex);
createNewItem.Click += new EventHandler(createNewItem_Click);
toolStripMenuItemNew.DropDownItems.Add(createNewItem);
}
}
toolStripMenuItemNew.Enabled = (toolStripMenuItemNew.DropDownItems.Count != 0);
if (_app != null)
{
_app.AppendContextMenuItems(_strip, emptyContentsClick ? null : context /*this.SelectedExplorerObjects*/);
}
CommandInterpreter.AppendMenuItems(_strip, exObject);
if (!emptyContentsClick)
{
//if (exObject is IExplorerObjectRenamable)
//{
// if (_strip.Items.Count > 0) _strip.Items.Add(new ToolStripSeparator());
// _strip.Items.Add(_renameMenuItem);
//}
//if (exObject is IExplorerObjectDeletable)
//{
// _strip.Items.Add(_deleteMenuItem);
//}
}
if (exObject is IExplorerObjectContextMenu)
{
ToolStripItem[] contextItems = ((IExplorerObjectContextMenu)exObject).ContextMenuItems;
if (contextItems != null && contextItems.Length > 0)
{
_strip.Items.Add(new ToolStripSeparator());
foreach (ToolStripItem contextItem in contextItems)
{
_strip.Items.Add(contextItem);
}
}
}
if (exObject is IExplorerObjectContextMenu2)
{
ToolStripItem[] contextItems = ((IExplorerObjectContextMenu2)exObject).ContextMenuItems(RefreshContents);
if (contextItems != null && contextItems.Length > 0)
{
_strip.Items.Add(new ToolStripSeparator());
foreach (ToolStripItem contextItem in contextItems)
{
_strip.Items.Add(contextItem);
}
}
}
var exObjectInstance = await exObject.GetInstanceAsync();
if (exObject != null && exObjectInstance is IFeatureClass)
{
IFeatureClass fc = (IFeatureClass)exObjectInstance;
if (fc.Dataset != null && fc.Dataset.Database is IFeatureDatabaseReplication)
{
_strip.Items.Add(new ToolStripSeparator());
_strip.Items.Add(_replicationMenuItem);
_appendReplicationIDMenuItem.Enabled = !await Replication.FeatureClassHasRelicationID(fc);
_checkoutMenuItem.Enabled = await Replication.FeatureClassCanReplicate(fc);
_checkinMenuItem.Enabled = (await Replication.FeatureClassGeneration(fc) > 0);
}
}
if (exObject is IMetadata)
{
_strip.Items.Add(new ToolStripSeparator());
_strip.Items.Add(_metadataMenuItem);
}
_contextObject = exObject;
return(_strip);
}
