private void SetTileSources(Rect imageRect, MultiScaleTileSource source)
{
double tileWidth = this.TileSize.Width * this.scaleFactor;
double tileHeight = this.TileSize.Height * this.scaleFactor;
int startTileX = (int)(imageRect.X / tileWidth);
int startTileY = (int)(imageRect.Y / tileHeight);
int endTileX = (int)Math.Ceiling(imageRect.Right / tileWidth) - 1;
int endTileY = (int)Math.Ceiling(imageRect.Bottom / tileWidth) - 1;
foreach (MapTile tile in this.mainCanvas.Children)
{
int tileX = startTileX + tile.RelativeTileId.X;
int tileY = startTileY + tile.RelativeTileId.Y;
if (tileX > endTileX || tileY > endTileY)
{
if (tile.Source != null)
{
tile.Source = null;
}
continue;
}
TileId tileId = new TileId(this.requestZoomLevel, tileX, tileY);
this.SetTileSource(tile, tileId, source);
}
}
private void OnTimerTick(object sender, EventArgs e)
{
DispatcherTimer timer = sender as DispatcherTimer;
if (timer != null)
{
if (this.unloaded)
{
this.arrangeTimer = null;
timer.Stop();
timer.Tick -= this.OnTimerTick;
MultiScaleTileSource source = this.multiScaleTileSource;
if (source != null)
{
source.StopDownload();
}
}
if (this.arrangeInvalidated)
{
this.arrangeInvalidated = false;
this.InvalidateArrange();
}
}
}
private void CreateTiles(MultiScaleTileSource tileSource)
{
int endTileX = (int)Math.Ceiling(this.ActualWidth / this.TileSize.Width);
int endTileY = (int)Math.Ceiling(this.ActualHeight / this.TileSize.Height);
int minTileNumber = (endTileX + 1) * (endTileY + 1);
tileSource.SetMinTileNumber(minTileNumber);
endTileX <<= 1;
endTileY <<= 1;
double top = 0;
for (int tileY = 0; tileY <= endTileY; tileY++)
{
double left = 0;
for (int tileX = 0; tileX <= endTileX; tileX++)
{
MapTile tile = new MapTile(this.TileSize, new Point(left, top));
tile.RelativeTileId = new TileId(this.requestZoomLevel, tileX, tileY);
this.mainCanvas.Children.Add(tile);
left += this.TileSize.Width;
}
top += this.TileSize.Height;
}
}
private bool RequestTile(int requestLevel, int tileX, int tileY)
{
TileId key = new TileId(requestLevel, tileX, tileY);
bool download = this.UpdateCachedTile(key);
if (download)
{
MultiScaleTileSource source = this.Source;
if (source != null)
{
source.DownloadTile(key);
}
}
return(download);
}
internal void Refresh()
{
if (!this.refreshInvoked && this.hasParameters)
{
MultiScaleTileSource source = this.Source;
if (source != null && !source.Dispatcher.HasShutdownStarted)
{
this.refreshInvoked = true;
source.Dispatcher.BeginInvoke(new Action(() =>
{
this.refreshInvoked = false;
this.processStart = true;
this.processRequest.Set();
}));
}
}
}
private void SetTileSource(MapTile tile, TileId tileId, MultiScaleTileSource source)
{
bool refresh = false;
if (!tileId.Equals(tile.TileId))
{
tile.TileId = tileId;
refresh = true;
}
while (true)
{
TileSource tileSource = source.GetTileSource(tileId);
if (tileSource != null)
{
if (tile.Source != tileSource || refresh)
{
tile.Source = tileSource;
}
if (tileSource.IsUsed)
{
this.usedTiles.Add(tileSource);
this.unusedTiles.Remove(tileSource);
break;
}
else
{
tileSource = null;
}
}
if (tileSource == null)
{
tileId = this.ReduceTileId(tileId);
if (tileId == null)
{
tile.Source = null;
break;
}
}
}
}
internal bool ValidateTile(TileId tileId)
{
if (!this.abort)
{
MultiscaleImageViewport viewport = this.parameters;
if (viewport.ActualWidth > 0 && viewport.ViewportWidth > 0)
{
int tileZoomLevelShift = (int)Math.Round(Math.Log(viewport.TileWidth, 2));
int tileLevel = tileId.Level - tileZoomLevelShift;
double zoom = viewport.ActualWidth / viewport.TileWidth / viewport.ViewportWidth;
int tileEndLevel = (int)Math.Ceiling(Math.Log(zoom, 2d));
if (tileLevel <= tileEndLevel)
{
double scale = Math.Pow(2d, Math.Log(zoom, 2d) - tileLevel);
MultiScaleTileSource tileSource = this.Source;
if (tileSource != null)
{
double width = tileSource.TileWidth * scale;
double height = tileSource.TileHeight * scale;
double x = tileId.X * width;
double y = tileId.Y * height;
double imageLeft = -viewport.ActualWidth * viewport.ViewportOrigin.X / viewport.ViewportWidth;
double imageTop = -viewport.ActualWidth * viewport.ViewportOrigin.Y / viewport.ViewportWidth;
Rect tileBounds = new Rect(x + imageLeft, y + imageTop, width, height);
Rect imageBounds = new Rect(0, 0, viewport.ActualWidth, viewport.ActualHeight);
imageBounds.Intersect(tileBounds);
if (!imageBounds.IsEmpty)
{
return(true);
}
}
}
}
this.RemoveRequest(tileId);
}
return(false);
}
private void OnSourceChanged(MultiScaleTileSource oldValue, MultiScaleTileSource newValue)
{
if (oldValue != null)
{
oldValue.TilesAvailable -= this.OnTilesAvailable;
}
if (newValue != null)
{
this.zoomLevelShift = (int)Math.Round(Math.Log(newValue.TileWidth, 2));
this.TileSize = new Size(newValue.TileWidth, newValue.TileHeight);
newValue.TilesAvailable += this.OnTilesAvailable;
}
this.multiScaleTileSource = newValue;
this.RenderViewport();
}
private void Arrange()
{
MultiScaleTileSource tileSource = this.multiScaleTileSource;
double internalViewportWidth = (double)this.GetValue(InternalViewportWidthProperty);
if (tileSource != null && !(tileSource is EmptyTileMapSource) && internalViewportWidth > 0)
{
MultiscaleImageViewport state = new MultiscaleImageViewport()
{
ViewportOrigin = this.viewportOrigin,
ViewportWidth = this.viewportWidth,
ActualWidth = this.ActualWidth,
ActualHeight = this.ActualHeight
};
tileSource.ProcessTilesDownload(state);
this.CalculateImageLocation();
this.ArrangeTiles();
}
}
private void ArrangeTiles()
{
MultiScaleTileSource tileSource = this.multiScaleTileSource;
if (this.ActualWidth > 0 && tileSource != null)
{
Rect imageRect = this.GetImageBounds();
bool empty = imageRect.IsEmpty;
if (!empty)
{
this.unusedTiles = this.usedTiles;
this.usedTiles = new HashSet <TileSource>();
if (this.RenderSize != this.oldSize)
{
this.oldSize = this.RenderSize;
foreach (MapTile tile in this.mainCanvas.Children)
{
tile.Source = null;
}
this.mainCanvas.Children.Clear();
this.CreateTiles(tileSource);
}
this.SetTileSources(imageRect, tileSource);
foreach (TileSource source in this.unusedTiles)
{
source.IsUsed = false;
source.ClearBitmap();
}
this.unusedTiles.Clear();
}
this.SetTransform(empty);
}
}
internal TilesDownloadManager(MultiScaleTileSource source)
{
this.multiScaleTileSource = new WeakReference(source);
this.MaxTileCacheSize = MultiScaleTileSource.DefaultTileCacheSize;
}