public void AdjustOrder(int insertIndex, ILayerItem item)
{
if (item.Tag is CodeCell.AgileMap.Core.ILayer)
{
foreach (GeoDo.RSS.Core.DrawEngine.ILayer layer in _viewer.Canvas.LayerContainer.Layers)
{
if (layer is IVectorHostLayer)
{
IVectorHostLayer hostLayer = layer as IVectorHostLayer;
IMap map = hostLayer.Map as IMap;
CodeCell.AgileMap.Core.ILayer lyr = item.Tag as CodeCell.AgileMap.Core.ILayer;
map.LayerContainer.AdjustOrder(lyr, map.LayerContainer.Layers[insertIndex]);
foreach (ILayerItem it in Items)
{
if (it is ILayerItemGroup && it.Tag is IVectorHostLayer)
{
(it as ILayerItemGroup).Items.Remove(item);
(it as ILayerItemGroup).Items.Insert(insertIndex, item);
}
}
break;
}
}
}
if (item.Tag is GeoDo.RSS.Core.DrawEngine.IRenderLayer || item.Tag is IVectorHostLayer)
{
this.Items.Remove(item);
this.Items.Insert(insertIndex, item);
_viewer.Canvas.LayerContainer.Layers.Remove(item.Tag as GeoDo.RSS.Core.DrawEngine.ILayer);
_viewer.Canvas.LayerContainer.Layers.Insert(insertIndex, item.Tag as GeoDo.RSS.Core.DrawEngine.ILayer);
}
RefreshViewer();
}
private void TrySetAsyncDataArrivedNotify()
{
if (_provider == null)
{
return;
}
ICanvas c = _provider.Canvas;
if (c == null)
{
return;
}
IVectorHostLayer host = c.LayerContainer.VectorHost;
if (host == null)
{
return;
}
IMapRuntime runtime = host.MapRuntime as IMapRuntime;
if (runtime == null)
{
return;
}
runtime.AsyncDataArrivedNotify = this;
}
private void ViewIsChanged(object sender, ISmartWindow oldV, ISmartWindow newV)
{
if (newV == null)
{
(this.Controls[0] as UCLayerManagerPanel).Apply(null);
return;
}
if (newV is ICanvasViewer)
{
ICanvasViewer v = newV as ICanvasViewer;
if (v == null)
{
return;
}
IVectorHostLayer host = v.Canvas.LayerContainer.VectorHost;
if (host == null)
{
return;
}
(this.Controls[0] as UCLayerManagerPanel).Apply(v.LayerProvider as ILayersProvider);
}
else if (newV is ILayoutViewer)
{
ILayoutViewer v = newV as ILayoutViewer;
if (v == null)
{
return;
}
(this.Controls[0] as UCLayerManagerPanel).Apply(v.LayerProvider as ILayersProvider);
}
}
private void AddVectorLayerName(ICanvas canvas)
{
IVectorHostLayer vectorHost = canvas.LayerContainer.VectorHost;
if (vectorHost == null)
{
return;
}
Map map = vectorHost.Map as Map;
if (map == null)
{
return;
}
CodeCell.AgileMap.Core.ILayer[] layers = map.LayerContainer.Layers;
if (layers == null || layers.Length == 0)
{
return;
}
foreach (CodeCell.AgileMap.Core.ILayer layer in layers)
{
if (layer == null)
{
continue;
}
CreatItemByLayerName(layer.Name);
}
}
private void RemoveVectorLayer(ICanvas canvas, RadMenuItem item)
{
IVectorHostLayer vectorHost = canvas.LayerContainer.VectorHost;
if (vectorHost == null)
{
return;
}
Map map = vectorHost.Map as Map;
if (map == null)
{
return;
}
CodeCell.AgileMap.Core.ILayer[] layers = map.LayerContainer.Layers;
if (layers == null || layers.Length == 0)
{
return;
}
CodeCell.AgileMap.Core.ILayer removeLayer = null;
foreach (CodeCell.AgileMap.Core.ILayer layer in layers)
{
if (layer.Name == item.Tag.ToString())
{
removeLayer = layer;
}
}
if (removeLayer != null)
{
(vectorHost.Map as Map).LayerContainer.Remove(removeLayer);
}
}
private void RemoveAllVectorLayer(IVectorHostLayer hostLayer)
{
if (hostLayer == null)
{
return;
}
(hostLayer as IDisposable).Dispose();
GC.Collect();
//VectorHostLayer newHost = new VectorHostLayer(null);
//_canvas.LayerContainer.Layers.Add(newHost);
return;
/*
* IMap map = hostLayer.Map as IMap;
* if (map == null || map.LayerContainer.FeatureLayers == null || map.LayerContainer.FeatureLayers.Length == 0)
* return;
* List<string> layerNames = new List<string>();
* foreach (CodeCell.AgileMap.Core.IFeatureLayer lyr in map.LayerContainer.FeatureLayers)
* {
* IFeatureClass fetclass = lyr.Class as IFeatureClass;
* if (fetclass == null)
* continue;
* FileDataSource fds = fetclass.DataSource as FileDataSource;
* if (fds == null)
* continue;
* ICachedVectorData data = GlobalCacher.VectorDataGlobalCacher.GetData(fds.FileUrl);
* if (data != null)
* layerNames.Add(data.Identify);
* }
* map.LayerContainer.Clear(false);
* foreach(string fName in layerNames)
* GlobalCacher.VectorDataGlobalCacher.Release(fName);
* GC.Collect();
* */
}
private void RemoveVectorLayer(string filename)
{
try
{
ILayoutHost host = null;
ICanvas canvas = GetCanvasFromSession(ref host);
if (canvas == null)
{
return;
}
IVectorHostLayer vectorHost = canvas.LayerContainer.VectorHost;
if (vectorHost == null)
{
return;
}
Map map = vectorHost.Map as Map;
if (map == null)
{
return;
}
CodeCell.AgileMap.Core.ILayer _layer = shps[filename.ToLower()];
map.LayerContainer.Remove(_layer);
canvas.Refresh(enumRefreshType.VectorLayer);
if (host != null)
{
host.Render(true);
}
RefreshLayerManager();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void ClearLineLayers()
{
if (linLayerName == null || linLayerName.Count == 0)
{
return;
}
ICanvasViewer viewer = _session.SmartWindowManager.ActiveCanvasViewer;
if (viewer == null)
{
return;
}
CodeCell.AgileMap.Core.ILayer removeLayer = null;
foreach (string name in linLayerName)
{
foreach (GeoDo.RSS.Core.DrawEngine.ILayer layer in viewer.Canvas.LayerContainer.Layers)
{
if (layer is IVectorHostLayer)
{
IVectorHostLayer hostLayer = layer as IVectorHostLayer;
IMap map = hostLayer.Map as IMap;
if (map.LayerContainer != null)
{
removeLayer = map.LayerContainer.GetLayerByName(name);
}
if (removeLayer != null)
{
map.LayerContainer.Remove(removeLayer);
break;
}
}
}
}
Update();
}
private void UpdateLayerColor()
{
IVectorHostLayer hostLayer = _activeViewer.Canvas.LayerContainer.VectorHost as IVectorHostLayer;
if (hostLayer == null)
{
return;
}
IMap map = hostLayer.Map as IMap;
CodeCell.AgileMap.Core.ILayer lyr = map.LayerContainer.GetLayerByName(_layerName);
if (lyr != null)
{
CodeCell.AgileMap.Core.IFeatureLayer fetLayer = lyr as CodeCell.AgileMap.Core.IFeatureLayer;
ISymbol symbol = fetLayer.Renderer.CurrentSymbol;
if (symbol != null)
{
IFillSymbol fillSymbol = symbol as IFillSymbol;
if (fillSymbol == null)
{
return;
}
fillSymbol.OutlineSymbol.Color = btnColor.BackColor;
}
}
}
private void AddToCanvas(ICanvas c, bool isNeedCheckNormalImage, IVectorHostLayer host, string filename)
{
if (isNeedCheckNormalImage)
{
//无坐标的图片
if (c.IsRasterCoord)
{
return;
}
}
TryCreateOrbitProjection(c);
string extName = Path.GetExtension(filename).ToUpper();
switch (extName)
{
case ".MCD":
host.ChangeMap(filename);
break;
case ".SHP":
host.AddData(filename, null);
break;
}
c.Refresh(enumRefreshType.All);
}
private void CreateVectorHost()
{
ICanvas c = canvasHost1.Canvas;
_vectorHostLayer = new VectorHostLayer(null);
_vectorHostLayer.Set(c);
c.LayerContainer.Layers.Add(_vectorHostLayer as GeoDo.RSS.Core.DrawEngine.ILayer);
}
private void CreateVectorHost()
{
ICanvas c = canvasHost1.Canvas;
_vectorHostLayer = new VectorHostLayer(null);
_vectorHostLayer.Set(c);
c.LayerContainer.Layers.Add(_vectorHostLayer as GeoDo.RSS.Core.DrawEngine.ILayer);
TryApplyDefaultBackgroudLayer();
AddGeoGrid(c);
}
public void Remove(ILayerItem item)
{
if (item is ILayerItemGroup)
{
foreach (ILayerItem it in (item as ILayerItemGroup).Items)
{
this.Items.Remove(it);
}
if (item.Tag is IVectorHostLayer)
{
IVectorHostLayer hostLayer = item.Tag as IVectorHostLayer;
IMap map = hostLayer.Map as IMap;
if (map.LayerContainer.Layers != null && map.LayerContainer.Layers.Count() != 0)
{
foreach (CodeCell.AgileMap.Core.ILayer it in map.LayerContainer.Layers)
{
map.LayerContainer.Remove(it);
}
}
Update();
}
}
if (item.Tag is GeoDo.RSS.Core.DrawEngine.IRenderLayer)
{
if (item.Tag is GeoDo.RSS.Core.DrawEngine.IRasterLayer)
{
return;
}
else if (item.Tag is GeoDo.RSS.Core.DrawEngine.IVectorLayer)
{
IRenderLayer layer = item.Tag as IRenderLayer;
_viewer.Canvas.LayerContainer.Layers.Remove(item.Tag as IRenderLayer);
this.Items.Remove(item);
return;
}
}
if (item.Tag is CodeCell.AgileMap.Core.ILayer)
{
foreach (GeoDo.RSS.Core.DrawEngine.ILayer layer in _viewer.Canvas.LayerContainer.Layers)
{
if (layer is IVectorHostLayer)
{
IVectorHostLayer hostLayer = layer as IVectorHostLayer;
IMap map = hostLayer.Map as IMap;
map.LayerContainer.Remove(item.Tag as CodeCell.AgileMap.Core.ILayer);
Update();
}
}
this.Items.Remove(item);
}
RefreshViewer();
}
private void AddVectorLayer(string fname)
{
IDataFrame df = _host.ActiveDataFrame;
if (df == null)
{
return;
}
ICanvas canvas = (df.Provider as IDataFrameDataProvider).Canvas;
IVectorHostLayer vectorHostLayer = canvas.LayerContainer.VectorHost;
vectorHostLayer.AddData(fname, null);
}
private CodeCell.AgileMap.Core.ILayer TryGetLayer(string layerName)
{
IVectorHostLayer hostLayer = _activeViewer.Canvas.LayerContainer.VectorHost as IVectorHostLayer;
if (hostLayer == null)
{
return(null);
}
IMap map = hostLayer.Map as IMap;
CodeCell.AgileMap.Core.ILayer lyr = map.LayerContainer.GetLayerByName(layerName);
return(lyr);
}
private void CreateVectorHost()
{
TryApplyDefaultBackgroudLayer();
ICanvas canvas = this.canvasHost1.Canvas;
_vectorMapHostLayer = new VectorHostLayer(null);
_vectorMapHostLayer.Set(canvas);
canvas.LayerContainer.Layers.Add(_vectorMapHostLayer as GeoDo.RSS.Core.DrawEngine.ILayer);
_shpFileHostLayer = new VectorHostLayer(null);
_shpFileHostLayer.Set(canvas);
canvas.LayerContainer.Layers.Add(_shpFileHostLayer as GeoDo.RSS.Core.DrawEngine.ILayer);
LoadWorldMap();
AddGeoGrid(canvas);
}
private Feature[] SelectFeatures(CoordEnvelope evp, ICanvas canvas)
{
IVectorHostLayer hostLayer = canvas.LayerContainer.VectorHost as IVectorHostLayer;
if (hostLayer == null || hostLayer.Map == null)
{
return(null);
}
IMap map = hostLayer.Map as IMap;
IMapRuntime runtime = hostLayer.MapRuntime as IMapRuntime;
Envelope aoiEnvelope = new Envelope(evp.MinX, evp.MinY, evp.MaxX, evp.MaxY);
Feature[] features = runtime.HitTestByPrj(aoiEnvelope);
return(features);
}
private void GetItems(ICanvas canvas)
{
if (canvas == null || canvas.LayerContainer == null)
{
return;
}
foreach (GeoDo.RSS.Core.DrawEngine.ILayer layer in canvas.LayerContainer.Layers)
{
if (layer is IVectorHostLayer)
{
IVectorHostLayer hostLayer = layer as IVectorHostLayer;
IMap map = hostLayer.Map as IMap;
if (map != null)
{
LayerItemGroup vectorGroup = new LayerItemGroup("矢量层", "矢量层");
vectorGroup.IsVisible = true;
/*
* 为了能够在层管理器中修改整个地图的参数将tag设置为map对象
*/
//vectorGroup.Tag = layer;
vectorGroup.Tag = map;
if (map.LayerContainer.Layers != null && map.LayerContainer.Layers.Count() != 0)
{
foreach (CodeCell.AgileMap.Core.ILayer it in map.LayerContainer.Layers)
{
LayerItemCanvasViewer item = new LayerItemCanvasViewer(enumLayerTypes.BaseVector, null);
item.Name = it.Name;
item.IsVisible = it.IsRendered;
item.Tag = it;
vectorGroup.Items.Add(item);
}
}
this.Items.Add(vectorGroup);
}
}
else if (layer is IRenderLayer)
{
LayerItemCanvasViewer item = new LayerItemCanvasViewer(enumLayerTypes.Raster, null);
item.Name = layer.Name;
item.IsVisible = (layer as IRenderLayer).Visible;
item.IsSelected = true;
item.Tag = layer;
this.Items.Add(item);
}
}
}
private ILayerObjectBase GetLayerObject(IVectorHostLayer vectorHostLayer)
{
if (vectorHostLayer == null || vectorHostLayer.Map == null)
{
return(null);
}
IMap map = vectorHostLayer.Map as IMap;
if (map == null)
{
return(null);
}
ILayerObjecGroup g = new LayerObjectGroup("矢量层");
GetLayerObjects(map.LayerContainer.Layers, g);
return(g);
}
void UCGbalFirRevise_Disposed(object sender, EventArgs e)
{
if (_vectorMapHostLayer != null)
{
(_vectorMapHostLayer as VectorHostLayer).Dispose();
_vectorMapHostLayer = null;
}
if (_geoGridLayer != null)
{
_geoGridLayer.Dispose();
_geoGridLayer = null;
}
if (this.canvasHost1 != null)
{
this.canvasHost1.Canvas.Dispose();
this.canvasHost1.Dispose();
}
}
public static CodeCell.AgileMap.Core.IFeatureLayer CreateAndLoadVectorLayerForMicaps(ISmartSession session, ICanvas canvas, string fname, string dataTypeId, params object[] args)
{
if (string.IsNullOrEmpty(fname) || !File.Exists(fname))
{
return(null);
}
using (IVectorFeatureDataReader reader = MicapsDataReaderFactory.GetVectorFeatureDataReader(fname, dataTypeId))
{
if (reader == null)
{
return(null);
}
if (reader.Features != null)
{
MemoryDataSource mds = new MemoryDataSource(fname, reader.ShapeType, enumCoordinateType.Geographic, reader.Envelope, reader.Fields);
IFeatureClass fetClass = new FeatureClass(mds);
mds.AddFeatures(reader.Features);
CodeCell.AgileMap.Core.IFeatureLayer fetLayer = new FeatureLayer(fname, fetClass);
TryApplyStyle(fetLayer, dataTypeId);
IVectorHostLayer host = canvas.LayerContainer.VectorHost as IVectorHostLayer;
if (host != null)
{
host.Set(canvas);
IMapRuntime mapRuntime = host.MapRuntime as IMapRuntime;
if (mapRuntime != null)
{
IMap map = mapRuntime.Map as IMap;
if (map != null)
{
map.LayerContainer.Append(fetLayer);
FeatureLayer fetL = map.LayerContainer.Layers[0] as FeatureLayer;
FeatureClass fetC = fetL.Class as FeatureClass;
Envelope evp = fetC.FullEnvelope.Clone() as Envelope;
CoordEnvelope cvEvp = new CoordEnvelope(evp.MinX, evp.MaxX, evp.MinY, evp.MaxY);
canvas.CurrentEnvelope = cvEvp;
canvas.Refresh(enumRefreshType.All);
}
}
return(fetLayer);
}
}
}
return(null);
}
public override bool Open(string fname, out bool memoryIsNotEnough)
{
memoryIsNotEnough = false;
if (!MemoryIsEnoughChecker.MemoryIsEnouggWithMsgBoxForVector(fname))
{
memoryIsNotEnough = true;
return(false);
}
bool isSpatial = IsCanAddToView(fname);
//string mcd = TryGetMcd(fname);//不能在这里用mcd替换
//if (!string.IsNullOrWhiteSpace(mcd))
// fname = mcd;
if (_session.SmartWindowManager.ActiveViewer is ICanvasViewer && isSpatial)
{
AddVectorDataToCanvasViewer(fname, true);
}
else if (_session.SmartWindowManager.ActiveViewer is ILayoutViewer)
{
AddVectorDataToLayoutViewer(fname, true);
}
else
{
CanvasViewer cv = new CanvasViewer(OpenFileFactory.GetTextByFileName(fname), _session);
_session.SmartWindowManager.DisplayWindow(cv);
IVectorHostLayer host = cv.Canvas.LayerContainer.VectorHost as IVectorHostLayer;
if (host != null)
{
host.Set(cv.Canvas);
AddVectorDataToCanvasViewer(fname, false);
CodeCell.AgileMap.Core.IMap map = host.Map as CodeCell.AgileMap.Core.IMap;
CodeCell.AgileMap.Core.FeatureLayer fetL = map.LayerContainer.Layers[0] as CodeCell.AgileMap.Core.FeatureLayer;
CodeCell.AgileMap.Core.FeatureClass fetc = fetL.Class as CodeCell.AgileMap.Core.FeatureClass;
CodeCell.AgileMap.Core.Envelope evp = fetc.FullEnvelope.Clone() as CodeCell.AgileMap.Core.Envelope;
CoordEnvelope cvEvp = new CoordEnvelope(evp.MinX, evp.MaxX, evp.MinY, evp.MaxY);
cv.Canvas.CurrentEnvelope = cvEvp;
cv.Canvas.Refresh(enumRefreshType.All);
}
}
RefreshLayerManager();
return(true);
}
private Dictionary <string, CodeCell.AgileMap.Core.ILayer> GetLoadedShp()
{
ILayoutHost host = null;
ICanvas canvas = GetCanvasFromSession(ref host);
if (canvas == null)
{
return(null);
}
IVectorHostLayer vectorHost = canvas.LayerContainer.VectorHost;
if (vectorHost == null)
{
return(null);
}
Map map = vectorHost.Map as Map;
if (map == null)
{
return(null);
}
CodeCell.AgileMap.Core.ILayer[] layers = map.LayerContainer.Layers;
if (layers == null || layers.Length == 0)
{
return(null);
}
Dictionary <string, CodeCell.AgileMap.Core.ILayer> shps = new Dictionary <string, CodeCell.AgileMap.Core.ILayer>();
foreach (CodeCell.AgileMap.Core.ILayer layer in layers)
{
try
{
string shp = (((layer as CodeCell.AgileMap.Core.IFeatureLayer).Class as FeatureClass).DataSource as FileDataSource).FileUrl;
shps.Add(shp.ToLower(), layer);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
return(shps);
}
public void AddVectorDataToCanvasViewer(string fname, bool isNeedCheckNormalImage, params object[] options)
{
ICanvasViewer v = _smartSession.SmartWindowManager.ActiveCanvasViewer;
if (v == null)
{
return;
}
ICanvas c = v.Canvas;
if (c == null)
{
return;
}
IVectorHostLayer host = c.LayerContainer.VectorHost as IVectorHostLayer;
if (host == null)
{
return;
}
}
private void GetLayerItemLayouts(ILayerItemGroup g, ILayerObjectContainer layerObjContainer)
{
ILayerObjectBase[] layers = layerObjContainer.LayerObjects.ToArray();
foreach (ILayerObjectBase obj in layers)
{
if (obj is ILayerObject)
{
ILayerObject layerObj = obj as ILayerObject;
ILayerItem it = new LayerObjectItem(layerObj);
g.Items.Add(it);
}
else
{
LayerItemGroup group = new LayerItemGroup(obj.Text ?? string.Empty, obj.Text ?? string.Empty);
IDataFrame df = layerObjContainer as IDataFrame;
if (df != null)
{
IDataFrameDataProvider prd = df.Provider as IDataFrameDataProvider;
if (prd != null)
{
ICanvas canvas = prd.Canvas;
if (canvas != null)
{
GeoDo.RSS.Core.DrawEngine.ILayerContainer lc = canvas.LayerContainer as GeoDo.RSS.Core.DrawEngine.ILayerContainer;
if (lc != null)
{
IVectorHostLayer hostLayer = canvas.LayerContainer.VectorHost;
if (hostLayer != null)
{
group.Tag = hostLayer.Map;
}
}
}
}
}
g.Items.Add(group);
GetLayerItemLayouts(group, (obj as ILayerObjecGroup).Children.ToArray());
}
}
}
public void AddVectorDataToLayoutViewer(string fname, bool isNeedCheckNormalImage, params object[] options)
{
ILayoutViewer v = _session.SmartWindowManager.ActiveViewer as ILayoutViewer;
if (v == null)
{
return;
}
IDataFrame df = v.LayoutHost.ActiveDataFrame;
if (df == null)
{
return;
}
IDataFrameDataProvider provider = df.Provider as IDataFrameDataProvider;
if (provider == null)
{
return;
}
ICanvas c = provider.Canvas;
if (c == null)
{
return;
}
IVectorHostLayer host = c.LayerContainer.VectorHost as IVectorHostLayer;
if (host == null)
{
return;
}
AddToCanvas(c, isNeedCheckNormalImage, host, fname);
//
c.Refresh(enumRefreshType.All);
//
(v.LayoutHost).SetActiveDataFrame2CurrentTool();
(v.LayoutHost).Render(true);
}
public static Bitmap GetBitmapUseOriResolution(this ICanvas canvas)
{
IVectorHostLayer hostLayer = canvas.LayerContainer.VectorHost;
if (hostLayer == null)
{
return(null);
}
IMapRuntime runtime = hostLayer.MapRuntime as IMapRuntime;
if (runtime == null)
{
return(null);
}
IPrimaryDrawObject priObj = canvas.PrimaryDrawObject;
Color oBackcolor = runtime.Map.MapArguments.BackColor;
try
{
Image bitmap = new Bitmap(priObj.Size.Width, priObj.Size.Height, PixelFormat.Format32bppArgb);
runtime.Map.MapArguments.BackColor = Color.Transparent;
Envelope imageGeoEnv = PrjToGeoEnv(priObj, priObj.OriginalEnvelope.Clone());
MapImageGeneratorDefault map = new MapImageGeneratorDefault(runtime);
runtime.Host = map as CodeCell.AgileMap.Core.IMapRuntimeHost;
map.GetMapImage(map.GeoEnvelope2Viewport(imageGeoEnv), new Size(priObj.Size.Width, priObj.Size.Height), ref bitmap);
return(bitmap as Bitmap);
}
finally
{
runtime.Host = hostLayer as CodeCell.AgileMap.Core.IMapRuntimeHost;
runtime.Map.MapArguments.BackColor = oBackcolor;
}
//IRenderLayer renderLayer = layer as IRenderLayer;//GeoGridLayer
//if (filter(layer) && renderLayer.Visible)
//{
// renderLayer.Render(this, drawArgs);
//}
}
void UCImageControl_Disposed(object sender, EventArgs e)
{
if (_aoiContainer != null)
{
(_aoiContainer as AOIContainerLayer).Dispose();
_aoiContainer = null;
}
if (_aoiGCPContainer != null)
{
(_aoiGCPContainer as AOIContainerLayer).Dispose();
_aoiGCPContainer = null;
}
if (_vectorHostLayer != null)
{
(_vectorHostLayer as VectorHostLayer).Dispose();
_vectorHostLayer = null;
}
if (canvasHost1 != null)
{
canvasHost1.Canvas.Dispose();
canvasHost1.Dispose();
}
}
public static CodeCell.AgileMap.Core.IFeatureLayer CreateAndLoadVectorLayerForMicaps(ISmartSession session, ICanvas canvas, string fname, Feature[] features)
{
if (string.IsNullOrEmpty(fname) || !File.Exists(fname))
{
return(null);
}
if (features != null)
{
MemoryDataSource mds = new MemoryDataSource(fname, enumShapeType.Polyline);
IFeatureClass fetClass = new FeatureClass(mds);
mds.AddFeatures(features);
CodeCell.AgileMap.Core.IFeatureLayer fetLayer = new FeatureLayer(fname, fetClass);
//TryApplyStyle(fetLayer, dataTypeId);
IVectorHostLayer host = canvas.LayerContainer.VectorHost as IVectorHostLayer;
if (host != null)
{
host.Set(canvas);
IMapRuntime mapRuntime = host.MapRuntime as IMapRuntime;
if (mapRuntime != null)
{
IMap map = mapRuntime.Map as IMap;
if (map != null)
{
map.LayerContainer.Append(fetLayer);
FeatureLayer fetL = map.LayerContainer.Layers[0] as FeatureLayer;
FeatureClass fetC = fetL.Class as FeatureClass;
Envelope evp = fetC.FullEnvelope.Clone() as Envelope;
GeoDo.RSS.Core.DrawEngine.CoordEnvelope cvEvp = new GeoDo.RSS.Core.DrawEngine.CoordEnvelope(evp.MinX, evp.MaxX, evp.MinY, evp.MaxY);
canvas.CurrentEnvelope = cvEvp;
canvas.Refresh(enumRefreshType.All);
}
}
return(fetLayer);
}
}
return(null);
}
protected override CodeCell.AgileMap.Core.ISymbol GetSymbol()
{
if (string.IsNullOrEmpty(_layerName) || _dataFrame == null || _dataFrame.Provider == null)
{
return(null);
}
IDataFrameDataProvider provider = _dataFrame.Provider as IDataFrameDataProvider;
if (provider == null || provider.Canvas == null)
{
return(null);
}
IVectorHostLayer hostLayer = provider.Canvas.LayerContainer.VectorHost as IVectorHostLayer;
if (hostLayer == null)
{
return(null);
}
IMap map = hostLayer.Map as IMap;
if (map == null)
{
return(null);
}
CodeCell.AgileMap.Core.ILayer layer = map.LayerContainer.GetLayerByName(_layerName);
if (layer == null)
{
return(null);
}
CodeCell.AgileMap.Core.IFeatureLayer fetLayer = layer as CodeCell.AgileMap.Core.IFeatureLayer;
if (fetLayer == null || fetLayer.Renderer == null)
{
return(null);
}
return(fetLayer.Renderer.CurrentSymbol);
}
