/// <summary>
/// Constructs a Layer and attaches it to the specified layer container.
/// </summary>
/// <param name="container">Container to attach the layer to</param>
/// <remarks>
/// <seealso cref="Syncfusion.Windows.Forms.Diagram.ILayerContainer"/>
/// </remarks>
public Layer(ILayerContainer container)
{
this.container = container;
this.propertyValues = new Hashtable();
this.SetDefaultPropertyValues();
this.members = new ArrayList();
this.drawObjects = new ArrayList();
}
/// <summary>
/// Initialize new instance of <see cref="ToolTextSelection"/> class.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="layer">The selection shapes layer.</param>
/// <param name="shape">The selected shape.</param>
/// <param name="style">The selection shapes style.</param>
/// <param name="point">The selection point shape.</param>
public ToolTextSelection(IServiceProvider serviceProvider, ILayerContainer layer, ITextShape shape, IShapeStyle style, IBaseShape point)
{
_serviceProvider = serviceProvider;
_layer = layer;
_text = shape;
_style = style;
_point = point;
}
public SettingsLayer(ICamera camera, IScene scene, ISettingsManager <Settings> settingsManager,
ILayerContainer layerContainer)
{
_camera = camera;
_scene = scene;
_settingsManager = settingsManager;
_layerContainer = layerContainer;
}
/// <summary>
/// Initialize new instance of <see cref="ToolQuadraticBezierSelection"/> class.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="layer">The selection shapes layer.</param>
/// <param name="shape">The selected shape.</param>
/// <param name="style">The selection shapes style.</param>
/// <param name="point">The selection point shape.</param>
public ToolQuadraticBezierSelection(IServiceProvider serviceProvider, ILayerContainer layer, IQuadraticBezierShape shape, IShapeStyle style, IBaseShape point)
{
_serviceProvider = serviceProvider;
_layer = layer;
_quadraticBezier = shape;
_style = style;
_point = point;
}
/// <summary>
/// Initialize new instance of <see cref="ToolRectangleSelection"/> class.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="layer">The selection shapes layer.</param>
/// <param name="shape">The selected shape.</param>
/// <param name="style">The selection shapes style.</param>
/// <param name="point">The selection point shape.</param>
public ToolRectangleSelection(IServiceProvider serviceProvider, ILayerContainer layer, IRectangleShape shape, IShapeStyle style, IBaseShape point)
{
_serviceProvider = serviceProvider;
_layer = layer;
_rectangle = shape;
_style = style;
_point = point;
}
private void DeInitialize()
{
if (_layer != null)
{
_layer.InvalidateLayer -= Invalidate;
_layer = default;
}
}
/// <summary>
/// Add shape at specified index.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="layer">The layer instance.</param>
/// <param name="shape">The shape instance.</param>
/// <param name="index">The shape index.</param>
public static void AddShapeAt(this IProjectContainer project, ILayerContainer layer, IBaseShape shape, int index)
{
if (layer?.Shapes != null && shape != null)
{
var previous = layer.Shapes;
var next = layer.Shapes.Insert(index, shape);
project?.History?.Snapshot(previous, next, (p) => layer.Shapes = p);
layer.Shapes = next;
}
}
public ApplicationRunner(IApplication application, IWindow window, IEventDispatcher eventDispatcher,
ILayerContainer layerContainer, IRenderContext renderContext, Settings settings)
{
_application = application;
_window = window;
_eventDispatcher = eventDispatcher;
_layerContainer = layerContainer;
_renderContext = renderContext;
_settings = settings;
}
/// <summary>
/// Remove layer.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="layer">The layer instance.</param>
public static void RemoveLayer(this IProjectContainer project, ILayerContainer layer)
{
if (layer.Owner is IPageContainer container && container.Layers != null)
{
var previous = container.Layers;
var next = container.Layers.Remove(layer);
project?.History?.Snapshot(previous, next, (p) => container.Layers = p);
container.Layers = next;
}
}
/// <summary>
/// Remove shape.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="layer">The layer instance.</param>
/// <param name="shape">The shape instance.</param>
public static void RemoveShape(this IProjectContainer project, ILayerContainer layer, IBaseShape shape)
{
if (layer?.Shapes != null && shape != null)
{
var previous = layer.Shapes;
var next = layer.Shapes.Remove(shape);
project?.History?.Snapshot(previous, next, (p) => layer.Shapes = p);
layer.Shapes = next;
}
}
/// <summary>
/// Clear layer.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="layer">The layer instance.</param>
public static void ClearLayer(this IProjectContainer project, ILayerContainer layer)
{
if (layer != null)
{
var previous = layer.Shapes;
var next = ImmutableArray.Create <IBaseShape>();
project?.History?.Snapshot(previous, next, (p) => layer.Shapes = p);
layer.Shapes = next;
}
}
private void Initialize()
{
if (_layer != null)
{
DeInitialize();
}
if (DataContext is ILayerContainer layer)
{
_layer = layer;
_layer.InvalidateLayer += Invalidate;
}
}
/// <summary>
/// Add shapes.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="layer">The layer instance.</param>
/// <param name="shapes">The shapes collection.</param>
public static void AddShapes(this IProjectContainer project, ILayerContainer layer, IEnumerable <IBaseShape> shapes)
{
if (layer?.Shapes != null && shapes != null)
{
var builder = layer.Shapes.ToBuilder();
builder.AddRange(shapes);
var previous = layer.Shapes;
var next = builder.ToImmutable();
project?.History?.Snapshot(previous, next, (p) => layer.Shapes = p);
layer.Shapes = next;
}
}
/// <summary>
/// Replace shape at specified index.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="layer">The layer instance.</param>
/// <param name="shape">The shape instance.</param>
/// <param name="index">The shape index.</param>
public static void ReplaceShape(this IProjectContainer project, ILayerContainer layer, IBaseShape shape, int index)
{
if (layer != null && shape != null && index >= 0)
{
var builder = layer.Shapes.ToBuilder();
builder[index] = shape;
var previous = layer.Shapes;
var next = builder.ToImmutable();
project?.History?.Snapshot(previous, next, (p) => layer.Shapes = p);
layer.Shapes = next;
}
}
/// <summary>
/// Swap shape at specified indexes.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="layer">The layer instance.</param>
/// <param name="shape">The shape instance.</param>
/// <param name="insertIndex">The shape insert index.</param>
/// <param name="removeIndex">The shape remove index.</param>
public static void SwapShape(this IProjectContainer project, ILayerContainer layer, IBaseShape shape, int insertIndex, int removeIndex)
{
if (layer != null && shape != null && insertIndex >= 0 && removeIndex >= 0)
{
var builder = layer.Shapes.ToBuilder();
builder.Insert(insertIndex, shape);
builder.RemoveAt(removeIndex);
var previous = layer.Shapes;
var next = builder.ToImmutable();
project?.History?.Snapshot(previous, next, (p) => layer.Shapes = p);
layer.Shapes = next;
}
}
private void ReRender(RenderArgs arg, bool needComputeViewport)
{
if (_dummyBitmap != null)
{
_dummyBitmap.Dispose();
}
_dummyBitmap = new Bitmap(_environment.CanvasSize.Width, _environment.CanvasSize.Height);
if (needComputeViewport) //for web
{
ComputeViewportProjection();
}
_dummyEnvelope = ExtentOfProjectionCoord.Clone() as Envelope;
//
ILayerContainer layerContainer = _map.LayerContainer;
//计算用于快速坐标变换的参数
ComputeQuickArgs();
//构造缓存画布
using (Graphics g = Graphics.FromImage(_dummyBitmap))
{
g.SmoothingMode = _map.MapArguments.SmoothingMode;
g.Clear(_map.MapArguments.BackColor);
//重置冲突检测
if (_conflictorForSymbol != null && _conflictorForSymbol.Enabled)
{
_conflictorForSymbol.Reset();
}
//
if (_conflictorForLabel != null && _conflictorForLabel.Enabled)
{
_conflictorForLabel.Reset();
_labelRender.Begin(_conflictorForLabel, this as IFeatureRenderEnvironment);
}
else
{
_labelRender.Begin(null, this as IFeatureRenderEnvironment);
}
//绘制影像层
DrawRasterlayers(g);
//绘制几何形状
DrawAllGeometries(layerContainer, g);
//绘制标注
DrawAllLabels(layerContainer, g);
#region debug
//(_conflictorForLabel as PixelConflictor).Save();
#endregion
}
arg.Graphics.DrawImage(_dummyBitmap, 0, 0);
}
public RuntimeExchanger(IFeatureRenderEnvironment environment,
IMapRefresh mapRefresh, ILayerContainer featureLayerContainer,
IAsyncDataArrivedNotify asyncDataArrivedNotify)
{
_mapRefresh = mapRefresh;
_environment = environment;
_layerContainer = featureLayerContainer;
_asyncDataArrivedNotify = asyncDataArrivedNotify;
_idleEventHandler = new EventHandler(Application_Idle);
Application.Idle += _idleEventHandler;
_environment.OnTransformChanged += new OnTransformChangedHandler(TransformChanged);
_layerContainer.OnAddFeatureLayer += new OnAddLayerHandler(OnAddLayer);
_layerContainer.OnRemoveFeatureLayer += new OnRemoveLayerHandler(OnRemoveLayer);
cstReadingTaskCount = Environment.ProcessorCount;
}
public static bool TryToDelete(ILayerContainer container, IEnumerable <ConnectableShape> connectables, PointShape point)
{
foreach (var connectable in connectables)
{
if (connectable.Points.Contains(point))
{
connectable.Points.Remove(point);
connectable.MarkAsDirty(true);
return(true);
}
}
return(false);
}
public override void DrawHelpers(object dc, ILayerContainer container, ShapeRenderer renderer, double dx, double dy)
{
var shapes = container.Shapes;
var selection = renderer;
foreach (var shape in shapes)
{
if (selection.SelectedShapes.Contains(shape))
{
if (Helpers.TryGetValue(shape.GetType(), out var helper))
{
helper.Draw(dc, renderer, shape, selection, dx, dy);
}
}
}
}
private void Add(ILayerContainer layer)
{
if (layer == null)
{
return;
}
layer.PropertyChanged += ObserveLayer;
if (layer.Shapes != null)
{
Add(layer.Shapes);
}
layer.InvalidateLayer += ObserveInvalidateLayer;
}
private T FindLayerByDataset <T>(ILayerContainer container, string workspaceConnection, string dataset) where T : Layer
{
var layers = container.GetLayersAsFlattenedList().OfType <T>();
var layer = layers
.Where(l => {
if (!(l.GetDataConnection() is CIMStandardDataConnection))
{
return(false);
}
var conn = (CIMStandardDataConnection)l.GetDataConnection();
return(conn.WorkspaceConnectionString.Contains(workspaceConnection) && conn.Dataset == dataset);
})
.FirstOrDefault();
return(layer);
}
private void Remove(ILayerContainer layer)
{
if (layer == null)
{
return;
}
layer.PropertyChanged -= ObserveLayer;
if (layer.Shapes != null)
{
Remove(layer.Shapes);
}
layer.InvalidateLayer -= ObserveInvalidateLayer;
}
public static void Copy(ILayerContainer container, IEnumerable <BaseShape> shapes, ISelection selection)
{
var shared = GetPointsCopyDict(shapes);
foreach (var shape in shapes)
{
if (shape is ICopyable copyable)
{
var copy = (BaseShape)copyable.Copy(shared);
if (copy != null && !(copy is PointShape))
{
copy.Select(selection);
container.Shapes.Add(copy);
}
}
}
}
public LayerInfo[] GetLayerInfos()
{
ILayerContainer c = _gen.Map.LayerContainer;
if (c.Layers == null || c.Layers.Length == 0)
{
return(null);
}
List <LayerInfo> infos = new List <LayerInfo>();
foreach (IFeatureLayer lyr in c.Layers)
{
IFeatureClass fetclass = lyr.Class as IFeatureClass;
LayerInfo info = new LayerInfo(lyr.Name, lyr.Id, fetclass.ShapeType);
infos.Add(info);
}
return(infos.ToArray());
}
public static bool TryToDelete(ILayerContainer container, IEnumerable <GroupShape> groups, BaseShape shape)
{
foreach (var group in groups)
{
if (group.Shapes.Contains(shape))
{
group.Shapes.Remove(shape);
group.MarkAsDirty(true);
if (group.Shapes.Count <= 0)
{
container.Shapes.Remove(group);
}
return(true);
}
}
return(false);
}
public static void Delete(ILayerContainer container, ISelection selection)
{
var paths = container.Shapes.OfType <PathShape>();
var groups = container.Shapes.OfType <GroupShape>();
var connectables = container.Shapes.OfType <ConnectableShape>();
foreach (var shape in selection.SelectedShapes)
{
if (container.Shapes.Contains(shape))
{
container.Shapes.Remove(shape);
}
else if (container.Guides.Contains(shape))
{
if (shape is LineShape guide)
{
container.Guides.Remove(guide);
}
}
else
{
if (shape is PointShape point)
{
TryToDelete(container, connectables, point);
}
if (paths.Count() > 0)
{
TryToDelete(container, paths, shape);
}
if (groups.Count() > 0)
{
TryToDelete(container, groups, shape);
}
}
}
}
private void DrawAllLabels(ILayerContainer layerContainer, Graphics g)
{
IOutsideIndicator outsideIndicator = null;
int currentScale = _scale;
//
foreach (ILayerDrawable lyr in layerContainer.Layers)
{
if (!lyr.Visible)
{
continue;
}
IFeatureLayer fetLayer = lyr as IFeatureLayer;
if (fetLayer == null)
{
continue;
}
//如果图层未初始化
if (!fetLayer.IsReady)
{
continue;
}
//判断整个图层是否在可视区域之外
IFeatureClass fetclass = fetLayer.Class as IFeatureClass;
if (!fetclass.FullEnvelope.IsInteractived(_viewportProjection))
{
continue;
}
//判断几何形状是否显示，如果不显示，标注也不显示
if (!fetLayer.VisibleAtScale(currentScale))
{
continue;
}
//判断在当前比例尺下标注是否显示
if (!fetLayer.LabelDef.VisibleAtScale(currentScale))
{
continue;
}
//获取外部标识对象
outsideIndicator = (fetLayer as ISupportOutsideIndicator).OutsideIndicator;
if (outsideIndicator.IsOutside)
{
continue;
}
//判断是否启用标注
if (fetLayer.LabelDef == null || !fetLayer.LabelDef.EnableLabeling)
{
continue;
}
//判断网格集合是否为空
if (fetclass == null || fetclass.Grids == null || fetclass.Grids.Length == 0)
{
continue;
}
//只对点层进行标注冲突检测
bool conflictIsChanged = false;
if (_conflictorForLabel != null && _conflictorForLabel.Enabled)
{
conflictIsChanged = true;
//如果线采用注记形式，那么不做冲突检测
_conflictorForLabel.Enabled = !(fetclass.ShapeType == enumShapeType.Polyline && fetLayer.LabelDef.LabelSource == enumLabelSource.Annotation);
}
//逐网格进行标注
int gridCount = fetclass.Grids.Length;
for (int i = 0; i < gridCount; i++)
{
if (i > gridCount - 1)
{
continue;
}
//判断网格是否可见
outsideIndicator = (fetclass.Grids[i] as ISupportOutsideIndicator).OutsideIndicator;
if (outsideIndicator.IsOutside)
{
continue;
}
//判断网格内要素是否为空
Feature[] fets = fetclass.Grids[i].VectorFeatures.ToArray();
if (fets == null || fets.Length == 0)
{
continue;
}
//解决透明背景下，绘制文本出现黑色杂点的问题
g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.SingleBitPerPixelGridFit;
foreach (Feature fet in fets)
{
//判断要素是否可见
outsideIndicator = (fet as ISupportOutsideIndicator).OutsideIndicator;
if (outsideIndicator.IsOutside)
{
continue;
}
//画标注
_labelRender.Draw(_emptyRotateMatrix, g, fetLayer.LabelDef as LabelDef, fetLayer.Renderer.CurrentSymbol, fet, _quickTransfrom);
}
}
//
if (conflictIsChanged)
{
_conflictorForLabel.Enabled = true;
}
g.Flush(FlushIntention.Sync);
}
}
private void DrawAllGeometries(ILayerContainer layerContainer, Graphics g)
{
int currentScale = _scale;
try
{
ILayer[] layers = layerContainer.Layers;
IFeatureLayer fetlyr = null;
List <ILayerDrawable> twostepsLayers = new List <ILayerDrawable>();
IFeatureRenderer preRender = null;
foreach (ILayerDrawable lyr in layers)
{
if (!(lyr is IFeatureLayer))
{
continue;
}
fetlyr = lyr as IFeatureLayer;
if (preRender is IFeatureTwoStepRenderer && !(fetlyr.Renderer is IFeatureTwoStepRenderer))
{
FinishTwoStep(g, twostepsLayers);
}
preRender = fetlyr.Renderer;
(lyr as FeatureLayer)._isRendered = false;
if (!lyr.Visible)
{
continue;
}
//如果图层未初始化
if (!fetlyr.IsReady)
{
continue;
}
//判断整个图层是否在可视区域之外
IFeatureClass fetclass = fetlyr.Class as IFeatureClass;
if (!_viewportProjection.IsInteractived(fetclass.FullEnvelope))
{
continue;
}
//判断在当前比例尺下标注是否显示
if (!fetlyr.VisibleAtScale(currentScale))
{
continue;
}
//绘制几何形状
if (fetlyr.Renderer is IFeatureTwoStepRenderer)
{
twostepsLayers.Add(lyr);
//第一阶段
(fetlyr.Renderer as IFeatureTwoStepRenderer).StepType = enumTwoStepType.Outline;
}
//渲染几何形状
lyr.Render(g, _quickTransfrom);
(lyr as FeatureLayer)._isRendered = true;
//
g.Flush(FlushIntention.Sync);
}
if (twostepsLayers.Count > 0)//last layer
{
FinishTwoStep(g, twostepsLayers);
}
}
catch (Exception ex)
{
Log.WriterException(ex);
}
}
public void Render(RenderArgs arg)
{
if (_map == null || _isDisposed)
{
return;
}
ILayerContainer layerContainer = _map.LayerContainer;
if (layerContainer.IsEmpty() || _environment.CanvasSize == Size.Empty)
{
return;
}
#if DEBUG
int time = Environment.TickCount;
#endif
bool transformIsChanged = _preMapTransform == null || !MathHelper.MatrixIsSame(_preMapTransform, arg.Graphics.Transform);
bool envelopeIsChanged = _preFocusEnvelope == null || !_preFocusEnvelope.IsEquals(_environment.FocusEnvelope);
transformIsChanged = transformIsChanged || envelopeIsChanged;
bool needComputeViewportPrjAgain = true;
//for web
transformIsChanged = true;
//
if (transformIsChanged)
{
if (_transformChanged != null)
{
_transformChanged(this, null, null);
}
UpdateViewportAndTransformMatrix();
needComputeViewportPrjAgain = false;
}
Matrix oldM = arg.Graphics.Transform;
bool needRember = false;
try
{
arg.Graphics.Transform = _transformIdentity;
if (_environment.UseDummyMap && _dummyBitmap != null)
{
RenderUseDummyBitmap(arg);
}
else
{
if (transformIsChanged || layerContainer.LayerIsChanged || arg.IsReRender || _dummyBitmap == null)
{
ReRender(arg, needComputeViewportPrjAgain);
needRember = true;
(layerContainer as LayerContainer).ResetLayerIsChanged();
}
else
{
RenderUseDummyBitmap(arg);
}
}
}
finally
{
//画比例尺条
if (_scaleBarArgs != null && _scaleBarArgs.Enabled)
{
DrawScaleBar(arg.Graphics);
}
//画临时图层
DrawHandinessLayers(arg);
//
arg.Graphics.Transform = oldM;
arg.IsReRender = false;
arg.IsRendering = false;
}
if (needRember)
{
RemeberPreTransform(arg);
}
if (envelopeIsChanged)
{
if (_onViewExtentChanged != null)
{
_onViewExtentChanged.BeginInvoke(this, _environment.FocusEnvelope, null, null);
}
}
#if DEBUG
time = Environment.TickCount - time;
//Console.WriteLine("lost:" + time.ToString());
//_environment.Container.FindForm().Text = time.ToString();
#endif
}
internal void InternalInit(IProjectionTransform projectionTransform, IFeatureRenderEnvironment environment)
{
_mapRuntime = environment as IMapRuntime;
_layerContainer = new LayerContainer(projectionTransform, environment);
}
