// ********************************************************************************************************
// File name: Map.cpp
// Description: Implementation of the CMapView ActiveX Control class.
// ********************************************************************************************************
// The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); 
// you may not use this file except in compliance with the License. You may obtain a copy of the License at 
// http://www.mozilla.org/MPL/ 
// Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF 
// ANY KIND, either express or implied. See the License for the specific language governing rights and 
// limitations under the License. 
//
// The Original Code is MapWindow Open Source. 
//
// The Initial Developer of this version of the Original Code is Daniel P. Ames using portions created by 
// Utah State University and the Idaho National Engineering and Environmental Lab that were released as 
// public domain in March 2004.  
//
// Contributor(s): (Open source contributors should list themselves and their modifications here). 
// ----------------------------------------------------------------------------------------
// dpa, ah, Chris Michaelis (cdm), Stan, Tom Shanley (tws), Andrew Purkis (ajp), Ray Quay,
// Rob Cairns, Sergei Leschinski (lsu), Neio, sm, 
// ----------------------------------------------------------------------------------------

#include "stdafx.h"
#include "Map.h"
#include "MapPpg.h"
#include "Measuring.h"
#include "Tiles.h"
#include "ShapeEditor.h"
#include "UndoList.h"
#include "curl.h"
using namespace std;

//disable some known warnings we don't care about
#pragma warning(disable:4244)
#pragma warning(disable:4018)
#pragma warning(disable:4800)
#pragma warning(disable:4554)
#pragma warning(disable:4996)

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#pragma region Control info
IMPLEMENT_DYNCREATE(CMapView, COleControl)

// Property pages
// TODO: Add more property pages as needed.  Remember to increase the count!
BEGIN_PROPPAGEIDS(CMapView, 1)
	PROPPAGEID(CMapPropPage::guid)
END_PROPPAGEIDS(CMapView)

// Initialize class factory and guid
IMPLEMENT_OLECREATE_EX(CMapView, "MAPWINGIS.Map.1",
	0x54f4c2f7, 0xed40, 0x43b7, 0x9d, 0x6f, 0xe4, 0x59, 0x65, 0xdf, 0x7f, 0x95)

	// Type library ID and version
	IMPLEMENT_OLETYPELIB(CMapView, _tlid, _wVerMajor, _wVerMinor)

	// Interface IDs
	const IID BASED_CODE IID_DMap =
{ 0x1d077739, 0xe866, 0x46a0, { 0xb2, 0x56, 0x8a, 0xec, 0xc0, 0x4f, 0x23, 0x12 } };
const IID BASED_CODE IID_DMapEvents =
{ 0xabea1545, 0x8ab, 0x4d5c, { 0xa5, 0x94, 0xd3, 0x1, 0x72, 0x11, 0xea, 0x95 } };

// Control type information
static const DWORD BASED_CODE _dwMapOleMisc =
OLEMISC_ACTIVATEWHENVISIBLE |
OLEMISC_SETCLIENTSITEFIRST |
OLEMISC_INSIDEOUT |
OLEMISC_CANTLINKINSIDE |
OLEMISC_RECOMPOSEONRESIZE;

IMPLEMENT_OLECTLTYPE(CMapView, IDS_MAP, _dwMapOleMisc)

#pragma endregion

// ***********************************************************
// CMapView::CMapFactory::UpdateRegistry
// ***********************************************************
// Adds or removes system registry entries for CMap
BOOL CMapView::CMapViewFactory::UpdateRegistry(BOOL bRegister)
{
	// TODO: Verify that your control follows apartment-model threading rules.
	// Refer to MFC TechNote 64 for more information.
	// If your control does not conform to the apartment-model rules, then
	// you must modify the code below, changing the 6th parameter from
	// afxRegApartmentThreading to 0.

	if (bRegister)
		return AfxOleRegisterControlClass(
			AfxGetInstanceHandle(),
			m_clsid,
			m_lpszProgID,
			IDS_MAP,
			IDB_MAP,
			afxRegApartmentThreading,
			_dwMapOleMisc,
			_tlid,
			_wVerMajor,
			_wVerMinor);
	else
		return AfxOleUnregisterClass(m_clsid, m_lpszProgID);
}

BEGIN_EVENT_MAP(CMapView, COleControl)
	//{{AFX_EVENT_MAP(CMapView)
	// NOTE - ClassWizard will add and remove event map entries
	//    DO NOT EDIT what you see in these blocks of generated code !
	EVENT_CUSTOM_ID("MouseDown", eventidMouseDown, FireMouseDown, VTS_I2  VTS_I2  VTS_I4  VTS_I4)
	EVENT_CUSTOM_ID("MouseUp", eventidMouseUp, FireMouseUp, VTS_I2  VTS_I2  VTS_I4  VTS_I4)
	EVENT_CUSTOM_ID("MouseMove", eventidMouseMove, FireMouseMove, VTS_I2  VTS_I2  VTS_I4  VTS_I4)
	EVENT_CUSTOM_ID("FileDropped", eventidFileDropped, FireFileDropped, VTS_BSTR)
	EVENT_CUSTOM_ID("SelectBoxFinal", eventidSelectBoxFinal, FireSelectBoxFinal, VTS_I4  VTS_I4  VTS_I4  VTS_I4)
	EVENT_CUSTOM_ID("SelectBoxDrag", eventidSelectBoxDrag, FireSelectBoxDrag, VTS_I4  VTS_I4  VTS_I4  VTS_I4)
	EVENT_CUSTOM_ID("ExtentsChanged", eventidExtentsChanged, FireExtentsChanged, VTS_NONE)
	EVENT_CUSTOM_ID("MapState", eventidMapState, FireMapState, VTS_I4)
	EVENT_CUSTOM_ID("OnDrawBackBuffer", eventidOnDrawBackBuffer, FireOnDrawBackBuffer, VTS_I4)
	EVENT_CUSTOM_ID("ShapeHighlighted", eventidShapeHighlighted, FireShapeHighlighted, VTS_I4 VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("BeforeDrawing", eventidBeforeDrawing, FireBeforeDrawing, VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("AfterDrawing", eventidAfterDrawing, FireAfterDrawing, VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("TilesLoaded", eventidTilesLoaded, FireTilesLoaded, VTS_BOOL VTS_BSTR VTS_BOOL)
	EVENT_CUSTOM_ID("MeasuringChanged", eventidMeasuringChanged, FireMeasuringChanged, VTS_I4)
	EVENT_CUSTOM_ID("BeforeShapeEdit", eventidBeforeShapeEdit, FireBeforeShapeEdit, VTS_I4 VTS_I4 VTS_PI4)
	EVENT_CUSTOM_ID("ValidateShape", eventidValidateShape, FireValidateShape, VTS_I4 VTS_I4 VTS_DISPATCH VTS_PI4)
	EVENT_CUSTOM_ID("AfterShapeEdit", eventidAfterShapeEdit, FireAfterShapeEdit, VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("ChooseLayer", eventidChooseLayer, FireChooseLayer, VTS_I4 VTS_R8 VTS_R8 VTS_PI4)
	EVENT_CUSTOM_ID("ShapeValidationFailed", eventidShapeValidationFailed, FireShapeValidationFailed, VTS_BSTR)
	EVENT_CUSTOM_ID("BeforeDeleteShape", eventidBeforeDeleteShape, FireBeforeDeleteShape, VTS_I4 VTS_PI4)
	EVENT_CUSTOM_ID("ProjectionChanged", eventidProjectionChanged, FireProjectionChanged, VTS_NONE)
	EVENT_CUSTOM_ID("UndoListChanged", eventidUndoListChanged, FireUndoListChanged, VTS_NONE)
	EVENT_CUSTOM_ID("SelectionChanged", eventidSelectionChanged, FireSelectionChanged, VTS_I4)
	EVENT_CUSTOM_ID("ShapeIdentified", eventidShapeIdentified, FireShapeIdentified, VTS_I4 VTS_I4 VTS_R8 VTS_R8)
	EVENT_CUSTOM_ID("LayerProjectionIsEmpty", eventidLayerProjectionIsEmpty, FireLayerProjectionIsEmpty, VTS_I4 VTS_PI4)
	EVENT_CUSTOM_ID("ProjectionMismatch", eventidProjectionMismatch, FireProjectionMismatch, VTS_I4 VTS_PI4 VTS_PI4)
	EVENT_CUSTOM_ID("LayerReprojected", eventidLayerReprojected, FireLayerReprojected, VTS_I4 VTS_BOOL)
	EVENT_CUSTOM_ID("LayerAdded", eventidLayerAdded, FireLayerAdded, VTS_I4)
	EVENT_CUSTOM_ID("LayerRemoved", eventidLayerRemoved, FireLayerRemoved, VTS_I4 VTS_BOOL)
	EVENT_CUSTOM_ID("BackgroundLoadingStarted", eventidBackgroundLoadingStarted, FireBackgroundLoadingStarted, VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("BackgroundLoadingFinished", eventidBackgroundLoadingFinished, FireBackgroundLoadingFinished, VTS_I4 VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("GridOpened", eventidGridOpened, FireGridOpened, VTS_I4 VTS_BSTR VTS_I4 VTS_BOOL)
	EVENT_CUSTOM_ID("OnDrawBackBuffer2", eventidOnDrawBackBuffer2, FireOnDrawBackBuffer2, VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("BeforeLayers", eventidBeforeLayers, FireBeforeLayers, VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("AfterLayers", eventidAfterLayers, FireAfterLayers, VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("LayerReprojectedIncomplete", eventidLayerReprojectedIncomplete, FireLayerReprojectedIncomplete, VTS_I4 VTS_I4 VTS_I4)
	EVENT_CUSTOM_ID("BeforeVertexDigitized", eventidBeforeVertexDigitized, FireBeforeVertexDigitized, VTS_PR8 VTS_PR8)
	EVENT_CUSTOM_ID("SnapPointRequested", eventidSnapPointRequested, FireSnapPointRequested, VTS_R8 VTS_R8 VTS_PR8 VTS_PR8 VTS_PI4 VTS_PI4)
	EVENT_CUSTOM_ID("SnapPointFound", eventidSnapPointFound, FireSnapPointFound, VTS_R8 VTS_R8 VTS_PR8 VTS_PR8)
	EVENT_STOCK_DBLCLICK()
	//}}AFX_EVENT_MAP

	// Is never fired: EVENT_CUSTOM_ID("ShapesIdentified", eventidShapesIdentified, FireShapesIdentified, VTS_DISPATCH VTS_R8 VTS_R8)
END_EVENT_MAP()

#pragma region Constructor/destructor

// ********************************************************************
//		CMapView() constructor
// ********************************************************************
CMapView::CMapView()
	: _vals("AZ0CY1EX2GV3IT4KR5MP6ON7QL8SJ9UH0WF1DB2"),
	_valsLen(39), _isSnapshot(false),
	_brushBlue(NULL),
	_brushBlack(NULL),
	_brushWhite(NULL),
	_brushLightGray(NULL),
	_brushGray(NULL),
	_penGray(NULL),
	_penDarkGray(NULL),
	_propertyExchange(NULL),
	_bufferBitmap(NULL),
	_tilesBitmap(NULL),
	_layerBitmap(NULL),
	_drawingBitmap(NULL),
	_tempBitmap(NULL),
	_moveBitmap(NULL),
	_volatileBitmap(NULL)
{
	// GDI Plus Startup
	GdiplusStartup();

	Startup();
	SetDefaults();
}

// ****************************************************
//	    Destructor
// ****************************************************
CMapView::~CMapView()
{
	LockWindow(lmLock);   // we don't need any more redraws

	this->RemoveAllLayers();

	this->ClearDrawings();

	ReleaseTempObjects();

	this->Shutdown();

	// GDI Plus Shutdown
	// TileCacheManager::CloseAll is now by GdiplusShutdown,
	// managed within the reference count
	GdiplusShutdown();
}

// **********************************************************************
//	Clear
// **********************************************************************
void CMapView::Clear()
{
	this->RemoveAllLayers();
	this->ClearDrawings();
	ReleaseTempObjects();
	SetDefaults();

	CComPtr<IGeoProjection> p = NULL;
	ComHelper::CreateInstance(idGeoProjection, (IDispatch**)&p);
	SetGeoProjection(p);

	Redraw();
}

// **********************************************************************
//	Startup
// **********************************************************************
// Must be called from constructor only
void CMapView::Startup()
{
	InitializeIIDs(&IID_DMap, &IID_DMapEvents);

	_brushBlue = new Gdiplus::SolidBrush(Gdiplus::Color::Blue);
	_brushBlack = new Gdiplus::SolidBrush(Gdiplus::Color::Black);
	_brushWhite = new Gdiplus::SolidBrush(Gdiplus::Color::White);
	_brushLightGray = new Gdiplus::SolidBrush(Gdiplus::Color::LightGray);
	_brushGray = new Gdiplus::SolidBrush(Gdiplus::Color::Gray);
	_penGray = new Gdiplus::Pen(Gdiplus::Color::Gray);
	_penDarkGray = new Gdiplus::Pen(Gdiplus::Color::DarkSlateGray);

	Utility::InitGdiPlusFont(&_fontCourier, L"Courier New", 9.0f);
	Utility::InitGdiPlusFont(&_fontArial, L"Arial", 9.0f);
	_fontCourierSmall = new Gdiplus::Font(L"Courier New", 8.0f);
	_fontCourierLink = new Gdiplus::Font(L"Courier New", 8.0f);

	m_mapCursor = crsrMapDefault;
	_interactiveLayerHandle = -1;			// TODO: remove (currently not used)
	_panningAnimation = false;
	_zoombarTargetZoom = -1;
	_dragging.Move = CPoint(0, 0);
	_dragging.Start = CPoint(0, 0);
	_dragging.Operation = DragNone;
	_currentZoom = -1;
	_spacePressed = false;
	_lastRedrawTime = 0.0f;
	_projectionChangeCount = 0;
	_tileBuffer.Extents.left = 0.0;
	_tileBuffer.Extents.right = 0.0;
	_tileBuffer.Extents.top = 0.0;
	_tileBuffer.Extents.bottom = 0.0;
	_tileBuffer.Zoom = -1;
	_tileBuffer.Provider = (int)tkTileProvider::ProviderNone;
	_tileBuffer.Initialized = false;
	_tileProjectionState = ProjectionDoTransform;

	_globalCallback = NULL;

	m_key = "";

	_viewHeight = 0;
	_viewWidth = 0;

	//Cursors
	_cursorPan = AfxGetApp()->LoadCursor(IDC_PAN);
	_cursorZoomin = AfxGetApp()->LoadCursor(IDC_ZOOMIN);
	_cursorZoomout = AfxGetApp()->LoadCursor(IDC_ZOOMOUT);
	_cursorSelect = AfxGetApp()->LoadCursor(IDC_SELECT);
	_cursorMeasure = AfxGetApp()->LoadCursor(IDC_MEASURE);
	_cursorDigitize = AfxGetApp()->LoadCursor(IDC_DIGITIZE_CURSOR);
	_cursorVertex = AfxGetApp()->LoadCursor(IDC_VERTEX_CURSOR);
	_cursorRotate = AfxGetApp()->LoadCursor(IDC_ROTATE_CURSOR);
	_cursorMove = AfxGetApp()->LoadCursor(IDC_MOVE_CURSOR);
	_cursorSelect2 = AfxGetApp()->LoadCursor(IDC_SELECT2_CURSOR);
	_cursorIdentify = AfxGetApp()->LoadCursor(IDC_IDENTIFY_CURSOR);
	_cursorAlternatePan = AfxGetApp()->LoadCursor(IDC_PAN_ALTERNATE);

	_udCursor = NULL;

	_ttipCtrl = new CButton();
	m_drawMutex.Unlock();
	_mapstateMutex.Unlock();
	_setmaxstdio(2048);
	srand(time(NULL));

	_imageGroups = NULL;
	_hotTracking.Shapefile = NULL;
	_rotate = NULL;

	ComHelper::CreateInstance(idTiles, (IDispatch**)&_tiles);
	((CTiles*)_tiles)->Init(this);

	ComHelper::CreateInstance(idMeasuring, (IDispatch**)&_measuring);
	ComHelper::CreateInstance(idShapeEditor, (IDispatch**)&_shapeEditor);
	ComHelper::CreateInstance(idShapeEditor, (IDispatch**)&_geodesicShape);

	ComHelper::CreateInstance(idIdentifier, (IDispatch**)&_identifier);
	ComHelper::CreateInstance(idFileManager, (IDispatch**)&_fileManager);
	ComHelper::CreateInstance(idUndoList, (IDispatch**)&_undoList);
	((CUndoList*)_undoList)->SetMapCallback(this);

	ComHelper::CreateInstance(idSelectionList, (IDispatch**)&_identifiedShapes);
	ComHelper::CreateInstance(idShapefile, (IDispatch**)&_identifiedShapefile);
	ComHelper::CreateInstance(idDrawingRectangle, (IDispatch**)&_focusRectangle);
	_focusRectangle->put_Visible(VARIANT_TRUE);

	InitProjections();

	// let them all work by default 
	_customDrawingFlags = (tkCustomDrawingFlags)(BeforeAfterDrawing | BeforeAfterLayers | OnDrawBackBufferBitmapData | OnDrawBackBufferHdc);

	GetMeasuringBase()->SetMapCallback(this, ShapeInputMode::simMeasuring);
	_shapeEditor->SetMapCallback(this);
	_geodesicShape->SetMapCallback(this);

	// initialize cURL
	curl_global_init(CURL_GLOBAL_ALL);
}

// **********************************************************************
//	SetDefaults
// **********************************************************************
void CMapView::SetDefaults()
{
	// temp state variables
	_mouseTracking = false;
	_copyrightLinkActive = FALSE;
	_copyrightRect = Gdiplus::RectF(0.0F, 0.0F, 0.0F, 0.0F);
	_shapeCountInView = 0;
	_currentDrawing = -1;
	_rectTrackerIsActive = false;
	_lastWidthMeters = 0.0;
	_redrawId = 0;
	_lastZooombarPart = ZoombarNone;
	_hotTracking.LayerHandle = -1;
	_hotTracking.ShapeIndex = -1;
	_isSizing = false;
	_showingToolTip = FALSE;
	_lockCount = 0;
	_canUseLayerBuffer = false;
	_canUseVolatileBuffer = false;
	_canUseMainBuffer = false;
	_leftButtonDown = FALSE;
	_lastCursorMode = cmNone;
	_reverseZooming = false;
	_activeLayerPosition = 0;
	_knownExtents = keNone;
	_measuringPersistent = false;
	_lastErrorCode = tkNO_ERROR;
	// public control properties
	m_sendMouseMove = FALSE;
	m_sendMouseDown = FALSE;
	m_sendMouseUp = FALSE;
	m_sendSelectBoxDrag = FALSE;
	m_sendSelectBoxFinal = FALSE;
	m_sendOnDrawBackBuffer = FALSE;
	_extentHistoryCount = 20;
	m_doubleBuffer = TRUE;
	m_zoomPercent = 0.3;
	m_cursorMode = tkCursorMode::cmZoomIn;
	m_backColor = RGB(255, 255, 255);
	m_extentPad = 0.02;
	_rotateAngle = 0.0f;
	_canUseImageGrouping = FALSE;
	_grabProjectionFromData = TRUE;
	_hasHotTracking = false;
	_showCoordinates = cdmAuto;
	_zoomBehavior = zbUseTileLevels;
	_scalebarVisible = TRUE;
	_zoombarVisible = TRUE;
	_multilineLabeling = true;
	_mapResizeBehavior = rbClassic;
	_doTrapRMouseDown = TRUE;
	_useSeamlessPan = FALSE;
	_mouseWheelSpeed = 0.5;
	_shapeDrawingMethod = dmNewSymbology;
	_unitsOfMeasure = umMeters;
	_disableWaitCursor = false;
	_lineSeparationFactor = 3;
	_useLabelCollision = false;
	_showRedrawTime = FALSE;
	_showVersionNumber = FALSE;
	_scalebarUnits = tkScalebarUnits::GoogleStyle;
	_zoomBarVerbosity = tkZoomBarVerbosity::zbvFull;
	_panningInertia = csFalse;
	_reuseTileBuffer = TRUE;
	_zoomAnimation = csAuto;
	_zoomBoxStyle = tkZoomBoxStyle::zbsBlue;
	_identifierMode = imAllLayers;
	_zoomBarMinZoom = -1;
	_zoomBarMaxZoom = -1;
	_showCoordinatesFormat = afDegrees;
	_panningExtentsChanged = false;
	_prevExtentsIndex = 0;
	_useAlternatePanCursor = FALSE;
	_recenterMapOnZoom = FALSE;
	_showCoordinatesBackground = FALSE;

	// TODO: perhaps it's better to grab those from property exchanged (i.e. reverting only runtime changes)
	// perhaps this call can do this:
	//RequestAsynchronousExchange(GetPropertyExchangeVersion());

	((CTiles*)_tiles)->SetDefaults();
	GetMeasuringBase()->Clear();
}

// **********************************************************************
//	ReleaseTempObjects
// **********************************************************************
void CMapView::ReleaseTempObjects()
{
	_collisionList.Clear();

	_dragging.CloseShapefile();

	_rotateAngle = 0.0f;
	if (_rotate)
	{
		delete _rotate;
		_rotate = NULL;
	}

	if (_imageGroups)
	{
		for (int i = 0; i < _imageGroups->size(); i++)
		{
			delete (*_imageGroups)[i];
		}
		_imageGroups->clear();
		delete _imageGroups;
		_imageGroups = NULL;
	}
}


// **********************************************************************
//	Shutdown
// **********************************************************************
// Must be called from destructor only
void CMapView::Shutdown()
{
	// clean up cURL
	curl_global_cleanup();

	Utility::ClosePointer(&_fontCourier);
	Utility::ClosePointer(&_fontCourierSmall);
	Utility::ClosePointer(&_fontCourierLink);
	Utility::ClosePointer(&_fontArial);

	((CTiles*)_tiles)->Stop();

	if (_globalCallback)
		_globalCallback->Release();

	Utility::ClosePointer(&_bufferBitmap);
	Utility::ClosePointer(&_tilesBitmap);
	Utility::ClosePointer(&_drawingBitmap);
	Utility::ClosePointer(&_volatileBitmap);
	Utility::ClosePointer(&_moveBitmap);
	Utility::ClosePointer(&_tempBitmap);
	Utility::ClosePointer(&_layerBitmap);

	ClearPanningList();

	ReleaseProjections();

	if (_identifier)
		_identifier->Release();

	if (_fileManager)
		_fileManager->Release();

	if (_measuring)
		_measuring->Release();

	if (_shapeEditor)
		_shapeEditor->Release();

	if (_geodesicShape)
		_geodesicShape->Release();

	if (_undoList)
		_undoList->Release();

	if (_identifiedShapes)
		_identifiedShapes->Release();

	if (_identifiedShapefile)
		_identifiedShapefile->Release();

	if (_focusRectangle)
		_focusRectangle->Release();

	if (_tiles)
	{
		((CTiles*)_tiles)->ClearAll();
		_tiles->Release();
	}

	delete _ttipCtrl;
}

// ********************************************************************
//		OnCreate()
// ********************************************************************
int CMapView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (COleControl::OnCreate(lpCreateStruct) == -1)
		return -1;



	DragAcceptFiles(TRUE);

	CRect rect(0, 0, 0, 0);
	_ttipCtrl->Create(NULL, WS_CHILD, rect, this, IDC_TTBTN);
	_ttipCtrl->ShowWindow(FALSE);

	//CTool Tip
	_ttip.Create(this, TTS_ALWAYSTIP);
	_ttip.Activate(TRUE);
	_ttip.AddTool(this, "", rect, IDC_TTBTN);
	_ttip.SetDelayTime(TTDT_AUTOPOP, 0);
	_ttip.SetDelayTime(TTDT_INITIAL, 0);
	_ttip.SetDelayTime(TTDT_RESHOW, 0);

	return 0;
}
#pragma endregion

#pragma region Property exchange

// **********************************************************************
//	GetPropertyExchangeVersion
// **********************************************************************
DWORD CMapView::GetPropertyExchangeVersion()
{
	// properties can be added between versions, so let use a bit different numbering
	//return MAKELONG(_wVerMinor, _wVerMajor);
	return MAKELONG(49, 12);
}

// **********************************************************************
//	CMapView::DoPropExchange
// **********************************************************************
// Persistence support: http://msdn.microsoft.com/en-us/library/xxf9wx2c.aspx
void CMapView::DoPropExchange(CPropExchange* pPX)
{
	ExchangeVersion(pPX, GetPropertyExchangeVersion());		// version should be changed when new properties are added

	GetPropertyExchangeVersion();

	// this will exchange stock properties like BackColor or Enabled: 
	// http://msdn.microsoft.com/en-us/library/aa268861(v=vs.60).aspx
	COleControl::DoPropExchange(pPX);

	try
	{
		bool loading = pPX->IsLoading();

		PX_Color(pPX, "BackColor", m_backColor, RGB(255, 255, 255));
		PX_Double(pPX, "ExtentPad", m_extentPad, .02);
		PX_Short(pPX, "CursorMode", m_cursorMode, 0);
		PX_Double(pPX, "ZoomPercent", m_zoomPercent, .3);
		PX_Bool(pPX, "SendMouseMove", m_sendMouseMove, FALSE);
		PX_Bool(pPX, "SendMouseDown", m_sendMouseDown, FALSE);
		PX_Bool(pPX, "SendMouseUp", m_sendMouseUp, FALSE);
		PX_Bool(pPX, "SendSelectBoxDrag", m_sendSelectBoxDrag, FALSE);
		PX_Bool(pPX, "SendSelectBoxFinal", m_sendSelectBoxFinal, FALSE);
		PX_Long(pPX, "ExtentHistory", _extentHistoryCount, 20);
		PX_Bool(pPX, "DoubleBuffer", m_doubleBuffer, TRUE);
		PX_Bool(pPX, "SendOnDrawBackBuffer", m_sendOnDrawBackBuffer, FALSE);
		PX_Bool(pPX, "ShowRedrawTime", _showRedrawTime, FALSE);
		PX_Bool(pPX, "ShowVersionNumber", _showVersionNumber, FALSE);
		PX_Double(pPX, "MouseWheelSpeed", _mouseWheelSpeed, .5);
		PX_Bool(pPX, "UseSeamlessPan", _useSeamlessPan, FALSE);
		PX_Bool(pPX, "MultilineLabels", _multilineLabeling, FALSE);
		PX_Bool(pPX, "TrapRMouseDown", _doTrapRMouseDown, TRUE);
		PX_Bool(pPX, "DisableWaitCursor", _disableWaitCursor, FALSE);
		PX_Float(pPX, "MapRotationAngle", _rotateAngle, 0.0);
		PX_Bool(pPX, "CanUseImageGrouping", _canUseImageGrouping, FALSE);
		PX_Bool(pPX, "ScalebarVisible", _scalebarVisible, TRUE);

		// enumerated constants aren't supported directly so temp buffer will be used
		// we don't care about the direction of exchange, doing both getting and setting
		long temp;
		temp = (long)_mapResizeBehavior;
		PX_Long(pPX, "MapResizeBehavior", temp, 0);	//rbClassic
		_mapResizeBehavior = (tkResizeBehavior)temp;

		temp = (long)_zoomBehavior;
		PX_Long(pPX, "ZoomBehavior", temp, 1);	// zbUseTileLevels
		_zoomBehavior = (tkZoomBehavior)temp;

		temp = (long)_scalebarUnits;
		PX_Long(pPX, "ScalebarUnits", temp, 2);	//suGoogleStyle
		_scalebarUnits = (tkScalebarUnits)temp;

		temp = (long)_shapeDrawingMethod;
		PX_Long(pPX, "ShapeDrawingMethod", temp, 3);	// dmNewSymbology
		_shapeDrawingMethod = (tkShapeDrawingMethod)temp;

		temp = (long)_unitsOfMeasure;
		PX_Long(pPX, "MapUnits", temp, 6);			//umMeters
		_unitsOfMeasure = (tkUnitsOfMeasure)temp;

		temp = (long)_showCoordinates;
		PX_Long(pPX, "ShowCoordinates", temp, 1);			//cdmAuto
		_showCoordinates = (tkCoordinatesDisplay)temp;

		temp = (long)GetTileProvider();
		PX_Long(pPX, "TileProvider", temp, 0);		// OpenStreetMap
		SetTileProvider((tkTileProvider)temp);

		tkMapProjection projection;
		if (!loading) {
			projection = GetProjection();
			temp = (long)projection;
		}

		if (loading) {
			this->LockWindow(lmLock);
		}

		try
		{
			PX_Long(pPX, "Projection", temp, 0);			// PROJECTION_NONE
			projection = (tkMapProjection)temp;
			if (loading) {
				SetProjection(projection);
			}

			Extent extents;
			PX_Double(pPX, "xMin", extents.left, .3);
			PX_Double(pPX, "xMax", extents.right, .3);
			PX_Double(pPX, "yMin", extents.bottom, .3);
			PX_Double(pPX, "yMax", extents.top, .3);

			if (loading) {
				SetExtentsCore(extents, false);
			}
		}
		catch (...) {
		}

		if (loading) {
			this->LockWindow(lmUnlock);
		}

		PX_Bool(pPX, "ShowZoomBar", _zoombarVisible, TRUE);
		PX_Bool(pPX, "GrabProjectionFromData", _grabProjectionFromData, TRUE);

		temp = (long)_zoomAnimation;
		PX_Long(pPX, "AnimationOnZooming", temp, 0);			// csAuto
		_zoomAnimation = (tkCustomState)temp;

		temp = (long)_panningInertia;
		PX_Long(pPX, "InertiaOnPanning", temp, 0);			// csAuto
		_panningInertia = (tkCustomState)temp;

		PX_Bool(pPX, "ReuseTileBuffer", _reuseTileBuffer, TRUE);

		temp = (long)_zoomBarVerbosity;
		PX_Long(pPX, "ZoomBarVerbosity", temp, 1);			// zbvFull
		_zoomBarVerbosity = (tkZoomBarVerbosity)temp;

		temp = (long)_zoomBoxStyle;
		PX_Long(pPX, "ZoomBoxStyle", temp, 4);			// zbsBlue
		_zoomBoxStyle = (tkZoomBoxStyle)temp;

		PX_Long(pPX, "ZoombarMinZoom", _zoomBarMinZoom, -1);
		PX_Long(pPX, "ZoombarMaxZoom", _zoomBarMaxZoom, -1);

		temp = (long)_showCoordinatesFormat;
		PX_Long(pPX, "ShowCoordinatesFormat", temp, 0);			// afDegrees
		_showCoordinatesFormat = (tkAngleFormat)temp;

		PX_Bool(pPX, "UseAlternatePanCursor", _useAlternatePanCursor, FALSE);

		PX_Bool(pPX, "RecenterMapOnZoom", _recenterMapOnZoom, FALSE);

		PX_Bool(pPX, "ShowCoordinatesBackground", _showCoordinatesBackground, FALSE);
	}
	catch (...)
	{
	}
}
#pragma endregion

#pragma region Overidden properties
// ***********************************************************************
//	   CMapView::GetControlFlags
// ***********************************************************************
// Flags to customize MFC's implementation of ActiveX controls.
// For information on using these flags, please see MFC technical note
// #nnn, "Optimizing an ActiveX Control".
DWORD CMapView::GetControlFlags()
{
	DWORD dwFlags = COleControl::GetControlFlags();

	// The control's output is not being clipped.
	// The control guarantees that it will not paint outside its
	// client rectangle.
	dwFlags &= ~clipPaintDC;

	// The control will not be redrawn when making the transition
	// between the active and inactivate state.
	dwFlags |= noFlickerActivate;

	// The control can optimize its OnDraw method, by not restoring
	// the original GDI objects in the device context.
	dwFlags |= canOptimizeDraw;
	return dwFlags;
}

// ***************************************************************
//	CMapView::PreCreateWindow()
// ***************************************************************
BOOL CMapView::PreCreateWindow(CREATESTRUCT& cs)
{
	cs.style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CS_OWNDC | CS_BYTEALIGNWINDOW;
	return COleControl::PreCreateWindow(cs);
}
#pragma endregion


#pragma region GdiPlus
// ***************************************************************
//	CMapView::GdiplusStartup()
// ***************************************************************

/* Gdiplus startup/shutdown. Do it on a per control basis.
NB: this used to be in CMapViewWinGISApp::Init/ExitInstance.
These functions are called from DllMain during control registration
and MSDN says it's not allowed to call GdiplusStartup/Shutdown from DllMain.
Indeed, on our Win2003 and XP boxes, doing so hangs regsvr32.exe.

So, I decided on "gdiplus registration per control" strategy:
1. in ctor/dtor of the control, we bump up/down gdiplus count.
2. when count goes from/to 0, we call GdiplusStartup/Shutdown.
3. we protect GdiplusStartup/Shutdown calls by a critical section,
   to avoid multithreaded surprises (albeit multiple threads are, I think, highly unlikely).*/

   // IMPORTANT: the behavior is changed on 13 oct 14, startup/shutdown is moved back to
   // App::InitInstaance/App::ExitInstance because of issues with tile cache, which uses
   // GdiPlus::Bitmaps. It's desirable to keep it open even when the last CMapView contol
   // is destructed. Solution described at http://mikevdm.com/BlogEntry/Key/GdiplusShutdown-Hangs-Mysteriously
   // was implemented. Hopefully it will work.
   //
   // FOLLOW-UP: Having startup/shutdown being called in InitInstance/ExitInstance was not 
   // working properly from all development environments, and has been moved back to the CMapView
   // constructor/destructor.  The above-mentioned Tile cache issue is being handled by calling 
   // TileCacheManager::CloseAll() just prior to calling GdiplusShutdown.  This better follows
   // Microsoft's recommendations, and allows for transparent initialization whether or not the 
   // calling environment does it's own statrup and shutdown.  If any individual classes end up 
   // requiring GDI initialization outside of the map initialization, these can be handled on a 
   // case-by-case basis. (jf, 11/27/2019, https://mapwindow.atlassian.net/browse/MWGIS-205)

ULONG_PTR CMapView::ms_gdiplusToken = NULL;
ULONG_PTR CMapView::ms_gdiplusBGThreadToken = NULL;
unsigned CMapView::ms_gdiplusCount = 0;
::CCriticalSection CMapView::ms_gdiplusLock;
Gdiplus::GdiplusStartupOutput CMapView::ms_gdiplusStartupOutput;

void CMapView::GdiplusStartup()
{
	CSingleLock l(&ms_gdiplusLock, TRUE);
	if (ms_gdiplusCount == 0)
	{
		Gdiplus::GdiplusStartupInput gdiplusStartupInput;
		gdiplusStartupInput.SuppressBackgroundThread = TRUE;
		Gdiplus::Status s = Gdiplus::GdiplusStartup(&ms_gdiplusToken, &gdiplusStartupInput, &ms_gdiplusStartupOutput);
		if (s != Gdiplus::Ok)
		{
			TRACE(_T("GdiplusStartup failed, error: %d, GetLastError = %d\n"), s, GetLastError());
			ASSERT(FALSE);
			AfxThrowResourceException();
		}
		else {
			ms_gdiplusStartupOutput.NotificationHook(&ms_gdiplusBGThreadToken);
		}
	}
	ms_gdiplusCount++;
}

// ***************************************************************
//	CMapView::GdiplusShutdown()
// ***************************************************************
void CMapView::GdiplusShutdown()
{
	CSingleLock l(&ms_gdiplusLock, TRUE);
	ms_gdiplusCount--;
	if (ms_gdiplusCount == 0)
	{
		TileCacheManager::CloseAll();
		ms_gdiplusStartupOutput.NotificationUnhook(ms_gdiplusBGThreadToken);
		Gdiplus::GdiplusShutdown(ms_gdiplusToken);
		ms_gdiplusToken = NULL;
	}
}
#pragma endregion


// ***************************************************************
//	ClearPanningList
// ***************************************************************
void CMapView::ClearPanningList()
{
	if (_panningInertia != csFalse)
	{
		_panningLock.Lock();
		for (int i = 0; i < _panningList.size(); i++)
		{
			delete _panningList[i];
		}
		_panningList.clear();
		_panningLock.Unlock();
	}
}

// ***************************************************************
//	GetMeasuringBase
// ***************************************************************
MeasuringBase* CMapView::GetMeasuringBase()
{
	return ((CMeasuring*)_measuring)->GetBase();
}

// ***************************************************************
//	GetShapeEditorBase
// ***************************************************************
EditorBase* CMapView::GetEditorBase()
{
	return _shapeEditor->GetActiveShape();
}

// ***************************************************************
//	GetACtiveShape
// ***************************************************************
ActiveShape* CMapView::GetActiveShape()
{
	if (m_cursorMode == cmMeasure) return GetMeasuringBase();
	return GetEditorBase();
}

// ***************************************************************
//	GetLayerVisibleAtCurrentScale
// ***************************************************************
VARIANT_BOOL CMapView::GetLayerVisibleAtCurrentScale(LONG layerHandle)
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	if (!IsValidLayer(layerHandle)) return VARIANT_FALSE;
	Layer* l = _allLayers[layerHandle];
	if (IS_VALID_PTR(l))
	{
		double scale = GetCurrentScale();
		int zoom = GetCurrentZoom();
		return l->IsVisible(scale, zoom) ? VARIANT_TRUE : VARIANT_FALSE;
	}
	return VARIANT_FALSE;
}

// ***************************************************************
//	ZoomToEditor
// ***************************************************************
void CMapView::ZoomToEditor()
{
	CComPtr<IShape> shp = NULL;
	_shapeEditor->get_RawData(&shp);
	if (shp) {
		CComPtr<IExtents> ext = NULL;
		shp->get_Extents(&ext);
		if (ext) {
			double xMin, xMax, yMin, yMax, zMin, zMax;
			ext->GetBounds(&xMin, &yMin, &zMin, &xMax, &yMax, &zMax);
			Extent temp(xMin, xMax, yMin, yMax);
			if (_extents.Intersects(temp)) return;

			CComPtr<IPoint> pnt = NULL;
			ext->get_Center(&pnt);
			if (pnt) {
				double x, y;
				pnt->get_X(&x);
				pnt->get_Y(&y);
				double ratio = 2.0;   // increase the size
				double w = _extents.Width() * ratio;
				double h = _extents.Height() * ratio;
				Extent newExt(x - w / 2.0, x + w / 2.0, y - h / 2.0, y + h / 2.0);
				SetExtentsWithPadding(newExt);
			}
		}
	}
}

// ***************************************************************
//	StartDragging
// ***************************************************************
void CMapView::StartDragging(DraggingOperation operation)
{
	_dragging.Operation = operation;
	SetCapture();
}

// ************************************************************
//		GetIdentifiedShapes
// ************************************************************
ISelectionList* CMapView::GetIdentifiedShapes()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	if (_identifiedShapes) {
		_identifiedShapes->AddRef();
	}
	return _identifiedShapes;
}

// ************************************************************
//		GetFocusRectangle
// ************************************************************
IDrawingRectangle* CMapView::GetFocusRectangle()
{
	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	if (_focusRectangle) {
		_focusRectangle->AddRef();
	}
	return _focusRectangle;
}