{

private readonly ILayer _baseLayer;

private bool _onlyRedrawWhenComplete;

[NonSerialized]

private int _numPendingDownloads;

private readonly Size _cellSize;

private readonly Size _cellBuffer = new Size(5, 5);

private ImageAttributes _imageAttributes = new ImageAttributes();

[NonSerialized]

private object _renderLock = new object();

[NonSerialized]

private Bitmap _bitmap;

[NonSerialized]

private Envelope _lastViewport = new Envelope();

private class RenderTask

{

/// <summary>

/// The token to cancel the task

/// </summary>

internal System.Threading.CancellationTokenSource CancellationToken;

/// <summary>

/// The task

/// </summary>

internal System.Threading.Tasks.Task Task;

}

[NonSerialized]

private List<RenderTask> _currentTasks = new List<RenderTask>();

/// <summary>

/// Method to warp a usual layer in an async layer

/// </summary>

/// <param name="layer">The layer to wrap</param>

/// <param name="tileSize">The size of the tile</param>

/// <returns>A async tile layer</returns>

public static ILayer Create(ILayer layer, Size? tileSize = null)

{

if (layer == null)

throw new ArgumentNullException("layer");

if (layer is ITileAsyncLayer)

return layer;

tileSize = tileSize ?? new Size(256, 256);

return new AsyncLayerProxyLayer(layer, tileSize.Value);

}

/// <summary>

/// Creates an instance of this class

/// </summary>

/// <param name="baseLayer">The layer to proxy</param>

/// <param name="cellSize">The size of the tile</param>

private AsyncLayerProxyLayer(ILayer baseLayer, Size cellSize)

{

_baseLayer = baseLayer;

_cellSize = cellSize;

((ILayer)this).VisibilityUnits = baseLayer.VisibilityUnits;

}

double ILayer.MinVisible

{

get { return _baseLayer.MinVisible; }

set { _baseLayer.MinVisible = value; }

}

double ILayer.MaxVisible

{

get { return _baseLayer.MaxVisible; }

set { _baseLayer.MaxVisible = value; }

}

/// <summary>

/// Gets or Sets what level-reference the Min/Max values are defined in

/// </summary>

VisibilityUnits ILayer.VisibilityUnits { get; set; }

/// <summary>

/// Specifies whether this layer should be rendered or not

/// </summary>

bool ILayer.Enabled

{

get { return _baseLayer.Enabled; }

set { _baseLayer.Enabled = value; }

}

/// <summary>

/// Optional title of the layer. It will be used for services like WMS where both Name and Title are supported.

/// </summary>

public string LayerTitle

{

get { return _baseLayer.LayerTitle; }

set { _baseLayer.LayerTitle = value; }

}

/// <summary>

/// Name of layer

/// </summary>

string ILayer.LayerName

{

get { return _baseLayer.LayerName; }

set { _baseLayer.LayerName = value; }

}

/// <summary>

/// Gets the boundingbox of the entire layer

/// </summary>

Envelope ILayer.Envelope

{

get { return _baseLayer.Envelope; }

}

/// <summary>

/// The spatial reference ID (CRS)

/// </summary>

int ILayer.SRID

{

get { return _baseLayer.SRID; }

set { _baseLayer.SRID = value; }

}

/// <summary>

/// The spatial reference ID (CRS) that can be exposed externally.

/// </summary>

/// <remarks>

/// TODO: explain better why I need this property

/// </remarks>

int ILayer.TargetSRID

{

get { return _baseLayer.TargetSRID; }

}

/// <summary>

/// Proj4 String Projection

/// </summary>

string ILayer.Proj4Projection

{

get { return _baseLayer.Proj4Projection; }

set { _baseLayer.Proj4Projection = value; }

}

/// <summary>

/// Renders the layer

/// </summary>

/// <param name="g">Graphics object reference</param>

/// <param name="map">Map which is rendered</param>

void ILayer.Render(Graphics g, Map map)

{

((ILayer)this).Render(g, (MapViewport)map);

}

void ILayer.Render(Graphics g, MapViewport map)

{

// We don't need to regenerate the tiles

if (map.Envelope.Equals(_lastViewport) && _numPendingDownloads == 0)

{

g.DrawImage(_bitmap, Point.Empty);

return;

}

// Create a backbuffer

lock (_renderLock)

{

if (_bitmap == null || _bitmap.Size != map.Size)

{

_bitmap = new Bitmap(map.Size.Width, map.Size.Height, PixelFormat.Format32bppArgb);

using (var tmpGraphics = Graphics.FromImage(_bitmap))

tmpGraphics.Clear(Color.Transparent);

}

}

// Save the last viewport

_lastViewport = map.Envelope;

// Cancel old rendercycle

((ITileAsyncLayer)this).Cancel();

var mapViewport = map.Envelope;

var mapSize = map.Size;

var mapColumnWidth = _cellSize.Width+_cellBuffer.Width;

var mapColumnHeight = _cellSize.Height + _cellBuffer.Width;

var columns = (int)Math.Ceiling((double) mapSize.Width/mapColumnWidth);

var rows = (int) Math.Ceiling((double) mapSize.Height/mapColumnHeight);

var renderMapSize = new Size(columns * _cellSize.Width + _cellBuffer.Width,

rows * _cellSize.Height + _cellBuffer.Height);

var horizontalFactor = (double) renderMapSize.Width/mapSize.Width;

var verticalFactor = (double) renderMapSize.Height/mapSize.Height;

var diffX = 0.5d*(horizontalFactor*mapViewport.Width - mapViewport.Width);

var diffY = 0.5d*(verticalFactor*mapViewport.Height-mapViewport.Height);

var totalRenderMapViewport = mapViewport.Grow(diffX, diffY);

var columnWidth = totalRenderMapViewport.Width/columns;

var rowHeight = totalRenderMapViewport.Height/rows;

var rmdx = (int)((mapSize.Width-renderMapSize.Width) * 0.5f);

var rmdy = (int)((mapSize.Height - renderMapSize.Height) * 0.5f);

var tileSize = Size.Add(_cellSize, Size.Add(_cellBuffer, _cellBuffer));

var miny = totalRenderMapViewport.MinY;

var pty = rmdy + renderMapSize.Height - tileSize.Height;

for (var i = 0; i < rows; i ++)

{

var minx = totalRenderMapViewport.MinX;

var ptx = rmdx;

for (var j = 0; j < columns; j++)

{

var tmpMap = new Map(_cellSize);

tmpMap.Layers.Add(_baseLayer);

tmpMap.DisposeLayersOnDispose = false;

tmpMap.ZoomToBox(new Envelope(minx, minx + columnWidth, miny, miny + rowHeight));

var cancelToken = new System.Threading.CancellationTokenSource();

var token = cancelToken.Token;

var pt = new Point(ptx, pty);

var t = new System.Threading.Tasks.Task(delegate

{

if (token.IsCancellationRequested)

token.ThrowIfCancellationRequested();

var res = RenderCellOnThread(token, pt, tmpMap);

if (res)

{

System.Threading.Interlocked.Decrement(ref _numPendingDownloads);

var e = DownloadProgressChanged;

if (e != null)

e(_numPendingDownloads);

}

}, token);

var dt = new RenderTask {CancellationToken = cancelToken, Task = t};

lock (_currentTasks)

{

_currentTasks.Add(dt);

_numPendingDownloads++;

}

t.Start();

minx += columnWidth;

ptx += _cellSize.Width;

}

miny += rowHeight;

pty -= _cellSize.Height;

}

}

/// <summary>

/// Event raised when a new tile has been rendered an is now avalable

/// </summary>

public event MapNewTileAvaliabledHandler MapNewTileAvaliable;

/// <summary>

/// Event raised when the rendering of tiles has made progress

/// </summary>

public event DownloadProgressHandler DownloadProgressChanged;

bool ITileAsyncLayer.OnlyRedrawWhenComplete

{

get { return _onlyRedrawWhenComplete; }

set { _onlyRedrawWhenComplete = value; }

}

void ITileAsyncLayer.Cancel()

{

lock (_currentTasks)

{

foreach (var t in _currentTasks)

{

if (!t.Task.IsCompleted)

t.CancellationToken.Cancel();

}

_currentTasks.Clear();

_numPendingDownloads = 0;

}

}

int ITileAsyncLayer.NumPendingDownloads

{

get { return _numPendingDownloads; }

}

private bool RenderCellOnThread(System.Threading.CancellationToken token, Point ptInsert, Map map)

{

var tile = new Bitmap(map.Size.Width, map.Size.Height, PixelFormat.Format32bppArgb);

var mvp = new MapViewport(map);

using (var g = Graphics.FromImage(tile))

{

g.Clear(Color.Transparent);

_baseLayer.Render(g, mvp);

map.Layers.Clear();

}

if (!token.IsCancellationRequested)

{

OnTileRendered(ptInsert, map.Envelope, tile);

return true;

}

return false;

}

/// <summary>

/// Method to raise the map tile available event

/// </summary>

/// <param name="ptInsert"></param>

/// <param name="env"></param>

/// <param name="bmp"></param>

protected virtual void OnTileRendered(Point ptInsert, Envelope env, Bitmap bmp)

{

if (!env.Equals(_lastViewport))

{

System.Threading.Monitor.Enter(_renderLock);

using (var g = Graphics.FromImage(_bitmap))

g.DrawImageUnscaled(bmp, ptInsert);

System.Threading.Monitor.Exit(_renderLock);

}

var h1 = MapNewTileAvaliable;

if (h1 != null)

{

h1(null, env, bmp, bmp.Width, bmp.Height, _imageAttributes);

}

var h2 = DownloadProgressChanged;

if (h2 != null)

{

System.Threading.Interlocked.Decrement(ref _numPendingDownloads);

h2(_numPendingDownloads);

}

}

/// <summary>

/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

/// </summary>

/// <filterpriority>2</filterpriority>

public void Dispose()

{

((ITileAsyncLayer)this).Cancel();

_imageAttributes.Dispose();

}

void ICanQueryLayer.ExecuteIntersectionQuery(Envelope box, FeatureDataSet ds)

{

if (!((ICanQueryLayer)this).IsQueryEnabled)

return;

((ICanQueryLayer)_baseLayer).ExecuteIntersectionQuery(box, ds);

}

void ICanQueryLayer.ExecuteIntersectionQuery(IGeometry geometry, FeatureDataSet ds)

{

if (!((ICanQueryLayer)this).IsQueryEnabled)

return;

((ICanQueryLayer)_baseLayer).ExecuteIntersectionQuery(geometry, ds);

}

bool ICanQueryLayer.IsQueryEnabled

{

get

{

var cql = _baseLayer as ICanQueryLayer;

if (cql != null && cql.IsQueryEnabled)

return true;

return false;

}

set

{

var cql = _baseLayer as ICanQueryLayer;

if (cql != null )

cql.IsQueryEnabled = value;

}

}

[OnDeserialized]

private void OnDeserialized(StreamingContext context)

{

_imageAttributes = new ImageAttributes();

_currentTasks = new List<RenderTask>();

_renderLock = new object();

_lastViewport = new Envelope();

}