public void SetImage(MapImage newImage)
{
var oldImage = ExchangeImage(newImage);
if (oldImage != null)
{
oldImage.Dispose();
}
}
public void SetOrErase(MapImage newImage)
{
// It erases image if other one is present.
var oldImage = Interlocked.CompareExchange <MapImage>(ref image, newImage, null);
if (oldImage != null)
{
oldImage.Dispose();
}
}
public virtual void Draw(IViewport view, Graphics canvas, WebRequestsPool pool)
{
// Viewport is readonly.
Debug.Assert(view != null, "Viewport is missing!");
Debug.Assert(canvas != null, "Canvas is missing!");
Debug.Assert(pool != null, "WebRequestsPool is necessary for image downloading!");
var builder = new StringBuilder();
GetVisibleLayerNames(builder, IsCrsSupportedByParents());
if (builder.Length > 0)
{
var newView = view.Copy();
newView.ReduceViewBox(Wms.MaxWidth, Wms.MaxHeight);
var newImage = new MapImage(builder.ToString(), Wms.CRSId, newView, ImageFormat,
IsTransparent, BgColor);
try
{
// We cannot work with variable directly,
// because another thread could rewrite it during the work.
var oldImage = ReleaseImage();
try
{
if (IsVisible)
{
// Are we downloading?
if (AutoUpdate && Wms.IsDownloadingEnabled)
{
if ((oldImage == null) || (!newImage.Equals(oldImage)))
{
var requested = newImage;
newImage = null; // Do not dispose the object
pool.PutRequest(this, requested, requested.GetImageAddress(Wms));
if (oldImage != null)
{
oldImage.Draw(view, canvas);
}
}
else
{
// If the situation changes and there is requested the same image
// that already exists in the layer, outdated downloading is running
// at this moment and it must be interrupted.
pool.RemoveRequest(this);
oldImage.Draw(view, canvas);
}
}
else
{
// Downloading must be interrupted.
pool.RemoveRequest(this);
if (oldImage != null)
{
// Use an image with different CRS is nonsense.
if (oldImage.CRSEquals(newImage))
{
oldImage.Draw(view, canvas);
}
else
{
oldImage.Dispose();
oldImage = null; // Erase old image
}
}
}
}
else
{
if ((oldImage != null) && (!newImage.Equals(oldImage)))
{
oldImage.Dispose();
oldImage = null; // Erase old image
}
}
}
finally
{
// If another thread save new image, we prefer it.
SetOrErase(oldImage);
}
}
finally
{
if (newImage != null)
{
newImage.Dispose();
}
}
}
else
{
EraseImage(pool);
}
}
public MapImage ExchangeImage(MapImage newImage)
{
return(Interlocked.Exchange <MapImage>(ref image, newImage));
}
public bool CRSEquals(MapImage image)
{
return(crsId.Equals(image.crsId));
}
public void PutRequest(Layer layer, MapImage image, Uri uri)
{
Debug.Assert(layer != null, "New request must be identifiable by a layer!");
Debug.Assert(image != null, "New request must be able to download image by some information!");
Debug.Assert(uri != null, "Uri must be known before putting to the request pool!");
try
{
// Protected access to pool
lock (pool)
{
var isRequestedLayerSame = false;
var isLayerInProgressChanged = false;
// Lock for the currently running task
lock (taskLocker)
{
// Current task could be NO_REQUEST
if (layer.Equals(currentTask.Key))
{
isRequestedLayerSame = true;
if (!currentTask.Value.Value.Equals(image))
{
// If here comes different request for currently processed layer,
// we need to abord the running one.
currentTask = NO_REQUEST;
isLayerInProgressChanged = true;
}
}
}
if (isRequestedLayerSame)
{
if (isLayerInProgressChanged)
{
// New request instead of the aborded one
var newImage = image;
image = null;
pool.Add(layer, new AddressedImage(uri, newImage));
}
}
else
{
AddressedImage addressedImage;
if (pool.TryGetValue(layer, out addressedImage))
{
if (!addressedImage.Value.Equals(image))
{
// New request rewrites the old one.
var newImage = image;
image = null;
var oldImage = pool[layer];
pool[layer] = new AddressedImage(uri, newImage);
oldImage.Value.Dispose();
}
}
else
{
var newImage = image;
image = null;
pool.Add(layer, new AddressedImage(uri, newImage)); // Brend new request
}
}
}
}
finally
{
if (image != null)
{
image.Dispose();
}
}
waitEvent.Set();
}
