#include "stdafx.h"

#include "Map.h"

#include "Tiles.h"

#include "TilesDrawer.h"

#include "GeoProjection.h"

#include "ShapefileDrawing.h"

#include "ImageDrawing.h"

#include "LabelDrawing.h"

#include "ChartDrawing.h"

#include "Image.h"

#include "Measuring.h"

#include "GeometryHelper.h"

#include "LayerDrawer.h"

#include "ShapefileHelper.h"

#include "SelectionListHelper.h"

#include "ShapeStyleHelper.h"

#include "SelectionList.h"

#include "WmsHelper.h"

// ***************************************************************

// OnDraw()

// ***************************************************************

void CMapView::OnDraw(CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid)

{

if (_isSizing)

{

// An option to clear the control surface with back color before redraw while sizing

// but to leave the previous bitmap and to paint only the new regions seems nicer

//m_layerDC->FillSolidRect(rcBounds,m_backColor);

//ShowRedrawTime(0.0f, "Drawing...");

//pdc->BitBlt( 0, 0, rcBounds.Width(), rcBounds.Height(), m_layerDC, 0, 0, SRCCOPY);

return; // redraw is prohibited before the sizing will be finished

}

//This line is intended to ensure proper function in MSAccess by verifying that the hWnd handle exists

//before trying to draw. Lailin Chen - 2005/10/17

if (this->m_hWnd == NULL)

return;

// no redraw is allowed when the rubber band is being dragged

if (_rectTrackerIsActive)

return;

// the map is locked

if (_lockCount > 0)

return;

m_drawMutex.Lock(); // TODO: perhaps use lighter CCriticalSection

if (!_canUseMainBuffer || !_canUseVolatileBuffer || !_canUseLayerBuffer)

{

bool hasMouseMoveData = HasDrawingData(tkDrawingDataAvailable::MeasuringData) ||

HasDrawingData(tkDrawingDataAvailable::Coordinates) ||

HasDrawingData(tkDrawingDataAvailable::ZoomBox) ||

HasDrawingData(tkDrawingDataAvailable::ShapeDigitizing) ||

HasDrawingData(tkDrawingDataAvailable::FocusRect);

// if there is no move data, draws to output canvas directly

this->HandleNewDrawing(pdc, rcBounds, rcInvalid, !hasMouseMoveData);

if (hasMouseMoveData)

{

// the main drawing will be taken from the buffer as it wasn't passed to output canvas yet

DrawDynamic(pdc, rcBounds, rcInvalid, true);

}

}

else

{

// always draw the main buffer, even if there is no measuring data

DrawDynamic(pdc, rcBounds, rcInvalid, true);

}

m_drawMutex.Unlock();

}

// ***************************************************************

// HandleNewDrawing()

// ***************************************************************

void CMapView::HandleNewDrawing(CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid,

bool drawToOutputCanvas, float offsetX, float offsetY)

{

Gdiplus::Color backColor = Utility::OleColor2GdiPlus(m_backColor);

Gdiplus::Graphics* gBuffer = NULL; // for control rendering

Gdiplus::Graphics* gPrinting = NULL; // for snapshot drawing

Gdiplus::Graphics* g = NULL; // the right one to draw

// preparing graphics (for snapshot drawing to output canvas directly;

// for control rendering main buffer is used)

if (_isSnapshot)

{

gPrinting = Gdiplus::Graphics::FromHDC(pdc->GetSafeHdc());

gPrinting->TranslateTransform(offsetX, offsetY);

Gdiplus::RectF clip((Gdiplus::REAL)rcInvalid.left, (Gdiplus::REAL)rcInvalid.top, (Gdiplus::REAL)rcInvalid.Width(), (Gdiplus::REAL)rcInvalid.Height());

gPrinting->SetClip(clip);

Gdiplus::Color color(255, 255, 255, 255);

Gdiplus::SolidBrush brush(color);

gPrinting->Clear(color);

g = gPrinting;

}

else

{

gBuffer = Gdiplus::Graphics::FromImage(_bufferBitmap);

gBuffer->SetCompositingMode(Gdiplus::CompositingModeSourceOver);

gBuffer->Clear(backColor);

g = gBuffer;

}

// the main thing is to ensure that if new tile is coming it will trigger a new redraw,

// any tile after this moment will do it, otherwise a newcomer will be already in screen buffer

_canUseMainBuffer = true;

RedrawTiles(g, pdc);

RedrawWmsLayers(g);

DWORD startTick = ::GetTickCount();

bool layersRedraw = RedrawLayers(g, pdc, rcBounds);

RedrawVolatileData(g, pdc, rcBounds);

if (m_sendOnDrawBackBuffer)

{

// passing main buffer to client for custom drawing

FireOnDrawbackBufferCore(g, _isSnapshot ? NULL : _bufferBitmap);

}

RedrawTools(g, rcBounds);

// redraw time and logo

DWORD endTick = GetTickCount();

if (layersRedraw) {

_lastRedrawTime = (float)(endTick - startTick) / 1000.0f;

}

ShowRedrawTime(g, _lastRedrawTime, layersRedraw);

// uncomment to save screen buffers to the disk

//DumpBuffers();

// passing the main buffer to the screen if no other drawing will be needed

if (!_isSnapshot)

{

if (drawToOutputCanvas)

{

HDC hdc = pdc->GetSafeHdc();

Gdiplus::Graphics* g = Gdiplus::Graphics::FromHDC(hdc);

g->SetCompositingMode(Gdiplus::CompositingModeSourceCopy);

g->DrawImage(_bufferBitmap, 0.0f, 0.0f);

g->ReleaseHDC(pdc->GetSafeHdc());

delete g;

}

else {

// otherwise, there must be mouse move data and the buffer will be drawn there to avoid flickering

}

delete gBuffer;

}

else

{

gPrinting->ReleaseHDC(pdc->GetSafeHdc());

delete gPrinting;

}

}

// ***************************************************************

// DumpBuffers()

// ***************************************************************

void CMapView::DumpBuffers()

{

#ifndef RELEASE_MODE

CLSID clsid;

Utility::GetEncoderClsid(L"image/png", &clsid);

_bufferBitmap->Save(L"D:\\buffer.png", &clsid, NULL);

_drawingBitmap->Save(L"D:\\drawing.png", &clsid, NULL);

_tilesBitmap->Save(L"D:\\tiles.png", &clsid, NULL);

_layerBitmap->Save(L"D:\\layers.png", &clsid, NULL);

_volatileBitmap->Save(L"D:\\volatile.png", &clsid, NULL);

#endif

}

// ***************************************************************

// FireOnDrawbackBufferCore()

// ***************************************************************

void CMapView::FireOnDrawbackBufferCore(Gdiplus::Graphics* g, Gdiplus::Bitmap* bitmap)

{

// old way (doesn't support alpha channel)

if (g && (_customDrawingFlags & OnDrawBackBufferHdc))

{

HDC hdc = g->GetHDC();

FireOnDrawBackBuffer((long)hdc);

g->ReleaseHDC(hdc);

}

// new way (doesn't work for printing since there is no buffer bitmap in that case)

if (bitmap && (_customDrawingFlags & OnDrawBackBufferBitmapData))

{

Gdiplus::Rect r(0, 0, _bufferBitmap->GetWidth(), _bufferBitmap->GetHeight());

Gdiplus::BitmapData bmd;

_bufferBitmap->LockBits(&r, Gdiplus::ImageLockModeRead | Gdiplus::ImageLockModeWrite, _bufferBitmap->GetPixelFormat(), &bmd);

FireOnDrawBackBuffer2((long)bmd.Height, (long)bmd.Width, (long)bmd.Stride, (long)bmd.PixelFormat, (long)bmd.Scan0);

_bufferBitmap->UnlockBits(&bmd);

}

}

// ***************************************************************

// RedrawLayers()

// ***************************************************************

bool CMapView::RedrawLayers(Gdiplus::Graphics* g, CDC* dc, const CRect& rcBounds)

{

bool layersRedraw = false;

if (HasDrawingData(tkDrawingDataAvailable::LayersData))

{

if (_isSnapshot)

{

this->DrawLayers(rcBounds, g);

}

else

{

if (_canUseLayerBuffer)

{

bool dragging = _dragging.Operation == DragPanning &&

(_dragging.Start.x != 0 || _dragging.Start.y != 0 ||

_dragging.Move.x != 0 || _dragging.Move.y != 0);

int x = dragging ? _dragging.Move.x - _dragging.Start.x : 0;

int y = dragging ? _dragging.Move.y - _dragging.Start.y : 0;

// update from the layer buffer

g->DrawImage(_layerBitmap, (float)x, (float)y);

}

else

{

ClearHotTracking();

layersRedraw = true;

Gdiplus::Graphics* gLayers = Gdiplus::Graphics::FromImage(_layerBitmap);

gLayers->Clear(Gdiplus::Color::Transparent);

gLayers->SetCompositingMode(Gdiplus::CompositingModeSourceOver);

// fire external before layer drawing code

if (_customDrawingFlags & BeforeAfterLayers)

{

HDC hdc = g->GetHDC();

tkMwBoolean retVal = blnFalse;

this->FireBeforeLayers((long)hdc, rcBounds.left, rcBounds.right, rcBounds.top, rcBounds.bottom, &retVal);

g->ReleaseHDC(hdc);

}

bool useRotation = false; // not implemented

if (useRotation) {

DrawLayersRotated(dc, gLayers, rcBounds);

}

else {

DrawLayers(rcBounds, gLayers);

}

// passing layer buffer to the main buffer

g->DrawImage(_layerBitmap, 0.0f, 0.0f);

// clean up

delete gLayers;

}

// fire external after layer drawing code

// NOTE that we want to do this even if drawing from layer buffer (tkRedrawType::RedrawSkipDataLayers)

// since even that erases any custom drawing done through the hDC. We still should consider whether

// or not to allow After Layer drawing for the Snapshot (which is not done for the After Drawing draw)

if (_customDrawingFlags & BeforeAfterLayers)

{

HDC hdc = g->GetHDC();

tkMwBoolean retVal = blnFalse;

this->FireAfterLayers((long)hdc, rcBounds.left, rcBounds.right, rcBounds.top, rcBounds.bottom, &retVal);

g->ReleaseHDC(hdc);

}

}

}

_canUseLayerBuffer = true;

return layersRedraw;

}

// ***************************************************************

// RedrawWmsLayers()

// ***************************************************************

void CMapView::RedrawWmsLayers(Gdiplus::Graphics* g)

{

double scale = GetCurrentScale();

for (long i = 0; i < GetNumLayers(); i++)

{

Layer* layer = get_LayerByPosition(i);

if (!layer || layer->IsEmpty() || !layer->IsWmsLayer()) {

continue;

}

if (!layer->IsVisible(scale, _currentZoom)) {

continue;

}

CComPtr<IWmsLayer> wms = NULL;

layer->QueryWmsLayer(&wms);

TileManager* manager = WmsHelper::Cast(wms)->get_Manager();

if (!manager) return;

Gdiplus::Bitmap* wmsBuffer = WmsHelper::Cast(wms)->get_ScreenBuffer();

if (wmsBuffer)

{

if (manager->get_ScreenBufferChanged())

{

manager->MarkUndrawn();

}

bool hasUndrawn = manager->UndrawnTilesExist();

bool hasDrawn = manager->DrawnTilesExist();

if (!hasUndrawn && !hasDrawn)

{

return;

}

if (!hasUndrawn)

{

// take it from the buffer

g->DrawImage(wmsBuffer, 0.0f, 0.0f);

}

else

{

Gdiplus::Graphics* gWms = Gdiplus::Graphics::FromImage(wmsBuffer);

if (!hasDrawn)

{

gWms->Clear(Gdiplus::Color::Transparent);

}

TilesDrawer drawer(gWms, &_extents, _pixelPerProjectionX, _pixelPerProjectionY, PixelsPerMapUnit(), GetWgs84ToMapTransform());

drawer.DrawTiles(manager, GetMapProjection(), _isSnapshot, _projectionChangeCount);

g->DrawImage(wmsBuffer, 0.0f, 0.0f);

// clean up

delete gWms;

}

}

}

}

// ***************************************************************

// DrawTiles()

// ***************************************************************

void CMapView::RedrawTiles(Gdiplus::Graphics* g, CDC* dc)

{

if (HasDrawingData(tkDrawingDataAvailable::TilesData))

{

CTiles* tiles = (CTiles*)_tiles;

if (_isSnapshot)

{

get_TileManager()->MarkUndrawn();

DrawTiles(g);

get_TileManager()->MarkUndrawn();

}

else

{

bool zoomingAnimation = HasDrawingData(tkDrawingDataAvailable::ZoomingAnimation);

UpdateTileBuffer(dc, zoomingAnimation);

g->DrawImage(_tilesBitmap, 0.0f, 0.0f);

}

}

}

// ***************************************************************

// DrawVolatileData()

// ***************************************************************

void CMapView::RedrawVolatileData(Gdiplus::Graphics* g, CDC* dc, const CRect& rcBounds)

{

bool hasVolatile = HasVolatileShapefiles();

bool canUseBuffer = _canUseVolatileBuffer;

_canUseVolatileBuffer = true;

if (!hasVolatile && !HasDrawLists()) return;

ClearDrawingLabelFrames();

if (_isSnapshot)

{

if (hasVolatile)

this->DrawLayers(rcBounds, g, false);

this->DrawLists(rcBounds, g, dlSpatiallyReferencedList);

this->DrawLists(rcBounds, g, dlScreenReferencedList);

return;

}

if (canUseBuffer)

{

g->DrawImage(_volatileBitmap, 0.0f, 0.0f);

}

else {

// drawing layers

Gdiplus::Graphics* gDrawing = Gdiplus::Graphics::FromImage(_volatileBitmap);

gDrawing->Clear(Gdiplus::Color::Transparent);

// rendering of volatile shapefiles

if (HasVolatileShapefiles())

this->DrawLayers(rcBounds, gDrawing, false);

// fire external drawing

if (_customDrawingFlags & BeforeAfterDrawing)

{

HDC hdc = g->GetHDC();

tkMwBoolean retVal = blnFalse;

this->FireBeforeDrawing((long)hdc, rcBounds.left, rcBounds.right, rcBounds.top, rcBounds.bottom, &retVal);

g->ReleaseHDC(hdc);

}

// temp objects

this->DrawLists(rcBounds, gDrawing, dlSpatiallyReferencedList);

this->DrawLists(rcBounds, gDrawing, dlScreenReferencedList);

// passing layers to the main buffer

g->DrawImage(_volatileBitmap, 0.0f, 0.0f);

delete gDrawing;

// fire external drawing code

if (_customDrawingFlags & BeforeAfterDrawing)

{

HDC hdc = g->GetHDC();

tkMwBoolean retVal = blnFalse;

this->FireAfterDrawing((long)hdc, rcBounds.left, rcBounds.right, rcBounds.top, rcBounds.bottom, &retVal);

g->ReleaseHDC(hdc);

}

}

}

// ***************************************************************

// RedrawTools()

// ***************************************************************

void CMapView::RedrawTools(Gdiplus::Graphics* g, const CRect& rcBounds)

{

DrawShapeEditor(g, false);

if (!_isSnapshot)

{

DrawScaleBar(g);

DrawZoombar(g);

}

// distance measuring or persistent measuring

if (HasDrawingData(tkDrawingDataAvailable::MeasuringData))

{

GetMeasuringBase()->DrawData(g, false, DragNone);

}

DrawIdentified(g, rcBounds);

}

// ***************************************************************

// DrawIdentified()

// ***************************************************************

void CMapView::DrawIdentified(Gdiplus::Graphics* g, const CRect& rcBounds)

{

bool hotTracking = HasDrawingData(tkDrawingDataAvailable::HotTracking);

bool identified = HasDrawingData(tkDrawingDataAvailable::IdentifiedShapes);

if (!hotTracking && !identified)

return;

CShapefileDrawer drawer(g, &_extents, _pixelPerProjectionX, _pixelPerProjectionY, &_collisionList, GetCurrentScale(), GetCurrentZoom(), true);

if (hotTracking)

{

drawer.Draw(rcBounds, _hotTracking.Shapefile);

}

if (identified)

{

vector<long> handles;

if (SelectionListHelper::GetUniqueLayers(_identifiedShapes, handles))

{

vector<long> activeHandles;

for (size_t i = 0; i < handles.size(); i++)

{

Layer* layer = GetLayer(handles[i]);

if (layer && layer->wasRendered)

{

activeHandles.push_back(handles[i]);

}

}

if (activeHandles.size() > 0)

{

RenderSelectedPixels(activeHandles, drawer, rcBounds);

RenderIdentifiedShapes(activeHandles, drawer, rcBounds);

}

}

}

}

// ***************************************************************

// RenderIdentifiedShapes()

// ***************************************************************

void CMapView::RenderIdentifiedShapes(vector<long>& handles, CShapefileDrawer& drawer, const CRect& rcBounds)

{

VARIANT_BOOL vb;

for (size_t i = 0; i < handles.size(); i++)

{

Layer* layer = GetLayer(handles[i]);

if (!layer->wasRendered) continue;

if (layer->IsShapefile())

{

IShapefile* sf = GetShapefile(handles[i]);

if (!sf) continue;

// Shapefile.Create is called to change the ShapeType

SelectionListHelper::PopulateShapefile(_identifiedShapes, sf, _identifiedShapefile, handles[i]);

sf->Release();

// Shapefile.Create was called which cleared the style settings

ShapeStyleHelper::ApplyIdentifiedShapesStyle(_identifier, _identifiedShapefile, true);

drawer.Draw(rcBounds, _identifiedShapefile);

_identifiedShapefile->EditClear(&vb);

}

}

}

// ***************************************************************

// UpdateSelectedPixels()

// ***************************************************************

void CMapView::UpdateSelectedPixels(vector<long>& handles, bool& hasPolygons, bool& hasPoints)

{

hasPolygons = false;

hasPoints = false;

for (size_t i = 0; i < handles.size(); i++)

{

Layer* layer = GetLayer(handles[i]);

if (!layer->wasRendered) continue;

if (layer->IsImage())

{

CComPtr<IImage> img = NULL;

img.Attach(GetImage(handles[i]));

if (!img) continue;

// do we need polygon or point shapefile at this scale?

double dx, dy;

img->get_dX(&dx);

img->get_dY(&dy);

double size = (_pixelPerProjectionX * dx + _pixelPerProjectionY * dy) / 2.0;

bool polygon = size > 10;

if (polygon) {

hasPolygons = true;

}

if (!polygon) {

hasPoints = true;

}

// calculating bounds of pixels

((CSelectionList*)_identifiedShapes)->UpdatePixelBounds(handles[i], img, polygon);

}

}

}

// ***************************************************************

// RenderSelectedPixels()

// ***************************************************************

void CMapView::RenderSelectedPixels(vector<long>& handles, CShapefileDrawer& drawer, const CRect& rcBounds)

{

if (!SelectionListHelper::HasLayers(_identifiedShapes, ltRaster)) {

return;

}

bool hasPolygons, hasPoints;

UpdateSelectedPixels(handles, hasPolygons, hasPoints);

std::set<long> handlesSet(handles.begin(), handles.end());

if (hasPolygons)

{

SelectionListHelper::AddSelectedPixelsToShapefile(_identifiedShapes, _identifiedShapefile, handlesSet, true);

ShapeStyleHelper::ApplyIdentifiedShapesStyle(_identifier, _identifiedShapefile, true);

drawer.Draw(rcBounds, _identifiedShapefile);

}

if (hasPoints)

{

SelectionListHelper::AddSelectedPixelsToShapefile(_identifiedShapes, _identifiedShapefile, handlesSet, false);

ShapeStyleHelper::ApplyIdentifiedShapesStyle(_identifier, _identifiedShapefile, false);

_identifiedShapefile->put_CollisionMode(tkCollisionMode::AllowCollisions);

drawer.Draw(rcBounds, _identifiedShapefile);

}

VARIANT_BOOL vb;

_identifiedShapefile->EditClear(&vb);

}

// ***************************************************************

// UpdateTileBuffer

// ***************************************************************

void CMapView::UpdateTileBuffer( CDC* dc, bool zoomingAnimation )

{

CTiles* tiles = (CTiles*)_tiles;

Gdiplus::Graphics* gTiles = Gdiplus::Graphics::FromImage(_tilesBitmap);

int tileProvider = GetTileProvider();

bool initialization = !_tileBuffer.Initialized;

if (initialization)

{

_tileBuffer.Initialized = true;

// it's the first tile for current extents, we need to initialize the buffer

bool canReuseBuffer = /*ForceDiscreteZoom() &&*/

GetTileProvider() == _tileBuffer.Provider &&

_currentZoom != _tileBuffer.Zoom && abs(_currentZoom - _tileBuffer.Zoom) <= 4; // for larger difference it's not practical

bool wasReused = false;

if (canReuseBuffer && (_zoomAnimation || _reuseTileBuffer))

{

// reuse existing buffer

Gdiplus::Graphics* gTemp = Gdiplus::Graphics::FromImage(_tempBitmap);

Extent match;

if (_extents.getIntersection(_tileBuffer.Extents, match))

{

Gdiplus::RectF source, target;

DrawZoomingAnimation(match, gTemp, dc, source, target, zoomingAnimation);

if (_reuseTileBuffer)

{

Gdiplus::ImageAttributes attr;

gTemp->Clear(Gdiplus::Color::Transparent);

gTemp->Flush();

gTemp->DrawImage(_tilesBitmap, target, source.X, source.Y, source.Width, source.Height, Gdiplus::Unit::UnitPixel, &attr);

gTemp->Flush();

gTiles->Clear(Gdiplus::Color::Transparent);

gTiles->DrawImage(_tempBitmap, 0, 0 );

gTiles->Flush();

wasReused = true;

}

}

// clean up

delete gTemp;

}

if (!wasReused) {

gTiles->Clear(Gdiplus::Color::Transparent);

}

// save extents to reuse the buffer

_tileBuffer.Extents = _extents;

_tileBuffer.Zoom = _currentZoom;

_tileBuffer.Provider = tileProvider;

}

if (initialization) {

get_TileManager()->MarkUndrawn();

}

// drawing new tiles

if (initialization || get_TileManager()->UndrawnTilesExist()) {

DrawTiles(gTiles);

}

// clean up

delete gTiles;

}

// ***************************************************************

// DrawZoomingAnimation

// ***************************************************************

void CMapView::DrawZoomingAnimation( Extent match, Gdiplus::Graphics* gTemp, CDC* dc, Gdiplus::RectF& source, Gdiplus::RectF& target, bool zoomingAnimation )

{

// target rectangle (current screen buffer)

double tx = (match.left - _extents.left)/_extents.Width();

double tx2 = 1.0f - (_extents.right - match.right)/_extents.Width();

double ty = (_extents.top - match.top)/_extents.Height();

double ty2 = 1.0f - (match.bottom - _extents.bottom)/_extents.Height();

target.X = (float)(tx * _viewWidth);

target.Y = (float)(ty * _viewHeight);

target.Width = (float)((tx2 - tx) * _viewWidth);

target.Height = (float)((ty2 - ty) * _viewHeight);

// source rectangle (cached tile buffer)

Extent buffer = _tileBuffer.Extents;

double sx = (match.left - buffer.left)/buffer.Width();

double sx2 = 1.0f - (buffer.right - match.right)/buffer.Width();

double sy = (buffer.top - match.top)/buffer.Height();

double sy2 = 1.0f - (match.bottom - buffer.bottom)/buffer.Height();

source.X = (float)(sx * _tilesBitmap->GetWidth());

source.Y = (float)(sy * _tilesBitmap->GetHeight());

source.Width = (float)((sx2 - sx) * _tilesBitmap->GetWidth());

source.Height = (float)((sy2 - sy) * _tilesBitmap->GetHeight());

double x, x2, y, y2;

// -----------------------------------------------

// zooming animation

// -----------------------------------------------

if (zoomingAnimation)

{

HDC hdc = dc->GetSafeHdc();

Gdiplus::Graphics* g = Gdiplus::Graphics::FromHDC(hdc);

g->SetCompositingMode(Gdiplus::CompositingModeSourceCopy);

Gdiplus::Color backColor = Utility::OleColor2GdiPlus(m_backColor);

Gdiplus::ImageAttributes attr;

gTemp->Clear(backColor);

double steps = ((_viewHeight * _viewWidth > 1e6) ? 4 : 5) * abs(_currentZoom - _tileBuffer.Zoom);

DWORD lastTime, time;

DWORD redrawDelay = 40;

bool zoomingIn = _currentZoom > _tileBuffer.Zoom;

if (zoomingIn)

{

// portion of buffer is gradually scaled to the whole screen

for(int i = 1; i <= steps; i++)

{

x = i / steps * sx ;

x2 = sx2 + (1 - sx2) * (1 - i/steps);

y = i / steps * sy;

y2 = sy2 + (1 - sy2) * (1 - i/steps);

x *= _tilesBitmap->GetWidth();

x2 *= _tilesBitmap->GetWidth();

y *= _tilesBitmap->GetHeight();

y2 *= _tilesBitmap->GetHeight();

lastTime = GetTickCount();

// render to temp bitmap first as we need background color

gTemp->DrawImage(_tilesBitmap, target, (float)x, (float)y, (float)(x2 - x), (float)(y2 - y), Gdiplus::Unit::UnitPixel, &attr);

g->DrawImage(_tempBitmap, 0, 0 );

time = GetTickCount();

if (time - lastTime < redrawDelay )

Sleep(redrawDelay - time + lastTime);

}

}

else

{

// the whole buffer is gradually scale to the portion of the screen

Gdiplus::Color clr = Gdiplus::Color(backColor);

Gdiplus::SolidBrush brush(clr);

Gdiplus::RectF _lastTargetRect(target.X, target.Y, target.Width, target.Height);

Gdiplus::RectF tRect;

for(int i = 1; i <= steps ; i++)

{

x = i / steps * tx;

x2 = tx2 + (1 - tx2) * (1 - i/steps);

y = i / steps * ty;

y2 = ty2 + (1 - ty2) * (1 - i/steps);

tRect.X = (float)(x * _viewWidth);

tRect.Width = (float)(x2 * _viewWidth - tRect.X);

tRect.Y = (float)(y * _viewHeight);

tRect.Height =(float)(y2 * _viewHeight - tRect.Y);

lastTime = GetTickCount();

gTemp->FillRectangle(&brush, _lastTargetRect);

gTemp->DrawImage(_tilesBitmap, tRect, source.X, source.Y, source.Width, source.Height, Gdiplus::Unit::UnitPixel, &attr);

g->DrawImage(_tempBitmap, 0, 0 );

time = GetTickCount();

if (time - lastTime < redrawDelay )

Sleep(redrawDelay - time + lastTime);

_lastTargetRect.X = tRect.X;

_lastTargetRect.Y = tRect.Y;

_lastTargetRect.Width = tRect.Width;

_lastTargetRect.Height = tRect.Height;

}

}

g->ReleaseHDC(dc->GetSafeHdc());

delete g;

}

}

// ***************************************************************

// DrawTiles()

// ***************************************************************

void CMapView::DrawTiles(Gdiplus::Graphics* g)

{

int minZoom;

if ( GetTileMismatchMinZoom(minZoom) )

{

if (_currentZoom < minZoom) return;

}

TilesDrawer drawer(g, &_extents, _pixelPerProjectionX, _pixelPerProjectionY, PixelsPerMapUnit(), GetWgs84ToMapTransform());

drawer.DrawTiles(get_TileManager(), GetMapProjection(), _isSnapshot, _projectionChangeCount);

}

#pragma region Draw layers

// ****************************************************************

// DrawLayers()

// ****************************************************************

void CMapView::DrawLayers(const CRect & rcBounds, Gdiplus::Graphics* graphics, bool layerBuffer)

{

if (_lockCount > 0 && !_isSnapshot)

return;

// clear extents of drawn labels and charts

this->ClearLabelFrames();

register int i;

long startcondition = 0;

long endcondition = _activeLayers.size();

// nothing to draw

if (endcondition == 0)

return;

HCURSOR oldCursor;

if (layerBuffer) {

oldCursor = this->SetWaitCursor();

}

// ------------------------------------------------------------------

// Check whether some layers are completely concealed by images

// no need to draw them then

// ------------------------------------------------------------------

bool * isConcealed = new bool[endcondition];

memset(isConcealed,0,endcondition*sizeof(bool));

double scale = GetCurrentScale();

int zoom;

_tiles->get_CurrentZoom(&zoom);

if (layerBuffer)

CheckForConcealedImages(isConcealed, startcondition, endcondition, scale, zoom);

// drawing grouped images

if (layerBuffer)

DrawImageGroups();

// prepare for drawing

double currentScale = this->GetCurrentScale();

// collision avoidance

_collisionList.Clear();

CCollisionList collisionListLabels;

CCollisionList collisionListCharts;

CCollisionList* chosenListLabels = m_globalSettings.commonCollisionListForLabels ? (&_collisionList) : (&collisionListLabels);;

CCollisionList* chosenListCharts = m_globalSettings.commonCollisionListForCharts ? (&_collisionList) : (&collisionListCharts);;

// initializing classes for drawing

bool forceGdiplus = this->_rotateAngle != 0.0f || _isSnapshot;

CShapefileDrawer sfDrawer(graphics, &_extents, _pixelPerProjectionX, _pixelPerProjectionY, &_collisionList, this->GetCurrentScale(), this->GetCurrentZoom(), forceGdiplus);

CImageDrawer imgDrawer(graphics, &_extents, _pixelPerProjectionX, _pixelPerProjectionY, _viewWidth, _viewHeight);

CLabelDrawer lblDrawer(graphics, &_extents, _pixelPerProjectionX, _pixelPerProjectionY, currentScale, _currentZoom, chosenListLabels, _rotateAngle, _isSnapshot);

CChartDrawer chartDrawer(graphics, &_extents, _pixelPerProjectionX, _pixelPerProjectionY, currentScale, chosenListCharts, _isSnapshot);

// mark all shapes as not drawn

for (int i = startcondition; i < endcondition; i++)

{

Layer * l = _allLayers[_activeLayers[i]];

if (l->IsShapefile() && l->wasRendered) // if it's hidden don't clear every time

{

CComPtr<IShapefile> sf = NULL;

// don't mark as 'undrawn' if we're not going to redraw it

if (l->QueryShapefile(&sf) && ShapefileHelper::IsVolatile(sf) != layerBuffer)

{

ShapefileHelper::Cast(sf)->MarkUndrawn();

}

}

}

// run drawing

int shapeCount = 0;

for(int i = startcondition; i < endcondition; i++)

{

long layerHandle = _activeLayers[i];

Layer * l = _allLayers[layerHandle];

if (!l || !l->get_Object()) continue;

bool visible = l->IsVisible(scale, zoom) && !isConcealed[i];

l->wasRendered = visible;

if (visible)

{

if (l->IsImage())

{

if (!layerBuffer) continue;

DrawImageLayer(rcBounds, l, graphics, imgDrawer);

LayerDrawer::DrawLabels(l, lblDrawer, vpAboveParentLayer);

}

else if (l->IsShapefile() || l->IsDynamicOgrLayer())

{

CComPtr<IShapefile> sf = NULL;

if (l->IsDynamicOgrLayer())

{

// Try to get the data loaded so far & update labels & categories

l->UpdateShapefile();

// Get the shapefile

l->QueryShapefile(&sf);

}

else

{

// grab extents from shapefile in case they changed

l->UpdateExtentsFromDatasource();

if (!l->extents.Intersects(_extents))

continue;

// Update labels & categories

l->UpdateShapefile();

}

// layerBuffer == true indicates we're drawing the non-Volatile layers

if (l->QueryShapefile(&sf) && ShapefileHelper::IsVolatile(sf) == layerBuffer)

continue;

// Perform the draw:

sfDrawer.Draw(rcBounds, sf);

LayerDrawer::DrawLabels(l, lblDrawer, vpAboveParentLayer);

LayerDrawer::DrawCharts(l, chartDrawer, vpAboveParentLayer);

}

}

}

shapeCount = sfDrawer.GetShapeCount();

if (layerBuffer)

_shapeCountInView = shapeCount;

if (!layerBuffer && shapeCount > _shapeCountInView)

_shapeCountInView = shapeCount;

// drawing labels and charts above the layers

for (i = 0; i < (int)_activeLayers.size(); i++)

{

Layer * l = _allLayers[_activeLayers[i]];

if( !l || !l->get_Object()) continue;

if (!l->IsVisible(scale, zoom)) continue;

CComPtr<IShapefile> sf = NULL;

if (l->QueryShapefile(&sf) && ShapefileHelper::IsVolatile(sf) == layerBuffer)

continue;

LayerDrawer::DrawLabels(l, lblDrawer, vpAboveAllLayers);

LayerDrawer::DrawCharts(l, chartDrawer, vpAboveAllLayers);

}

if (layerBuffer && oldCursor != NULL) {

::SetCursor(oldCursor);

}

if (isConcealed)

delete[] isConcealed;

}

// ****************************************************************

// DrawImageLayer()

// ****************************************************************

void CMapView::DrawImageLayer(const CRect& rcBounds, Layer* l, Gdiplus::Graphics* graphics, CImageDrawer& imgDrawer)

{

if (!l->IsImage()) return;

IImage * iimg = NULL;

if (!l->QueryImage(&iimg)) return;

CImageClass* img = (CImageClass*)iimg;

if (_canUseImageGrouping && img->m_groupID != -1)

{

// this is grouped image, if this is the first image of group, we shall draw the whole group

if (!(*_imageGroups)[img->m_groupID]->wasDrawn)

{

this->DrawImageGroups(rcBounds, graphics, img->m_groupID);

(*_imageGroups)[img->m_groupID]->wasDrawn = true;