automap.cpp

电子地图的代码 实现一些空间功能 比如说放大 缩小等 是以美国为例

// Manually generated IDispatch wrapper class(es) created by ESRI

// NOTE: Do not modify the contents of this file.  

#include "stdafx.h"
#include "automap.h"


/////////////////////////////////////////////////////////////////////////////
// CMoAutoMap wrapper class for MapObjects 2.1 14th February 2001


/////////////////////////////////////////////////////////////////////////////
// CMoAutoMap properties

CMoLayers CMoAutoMap::GetLayers()
{
	LPDISPATCH pDispatch;
	GetProperty(0x4, VT_DISPATCH, (void*)&pDispatch);
	return CMoLayers(pDispatch);
}

void CMoAutoMap::SetLayers(LPDISPATCH propVal)
{
	SetProperty(0x4, VT_DISPATCH, propVal);
}

CMoRectangle CMoAutoMap::GetExtent()
{
	LPDISPATCH pDispatch;
	GetProperty(0x5, VT_DISPATCH, (void*)&pDispatch);
	return CMoRectangle(pDispatch);
}

void CMoAutoMap::SetExtent(LPDISPATCH propVal)
{
	SetProperty(0x5, VT_DISPATCH, propVal);
}

CMoRectangle CMoAutoMap::GetFullExtent()
{
	LPDISPATCH pDispatch;
	GetProperty(0x6, VT_DISPATCH, (void*)&pDispatch);
	return CMoRectangle(pDispatch);
}

void CMoAutoMap::SetFullExtent(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

OLE_COLOR CMoAutoMap::GetBackColor()
{
	OLE_COLOR result;
	GetProperty(DISPID_BACKCOLOR, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetBackColor(OLE_COLOR propVal)
{
	SetProperty(DISPID_BACKCOLOR, VT_I4, propVal);
}

short CMoAutoMap::GetBorderStyle()
{
	short result;
	GetProperty(DISPID_BORDERSTYLE, VT_I2, (void*)&result);
	return result;
}

void CMoAutoMap::SetBorderStyle(short propVal)
{
	SetProperty(DISPID_BORDERSTYLE, VT_I2, propVal);
}

BOOL CMoAutoMap::GetScrollBars()
{
	BOOL result;
	GetProperty(0x2, VT_BOOL, (void*)&result);
	return result;
}

void CMoAutoMap::SetScrollBars(BOOL propVal)
{
	SetProperty(0x2, VT_BOOL, propVal);
}

long CMoAutoMap::GetCancelAction()
{
	long result;
	GetProperty(0x8, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetCancelAction(long propVal)
{
	SetProperty(0x8, VT_I4, propVal);
}

CMoTrackingLayer CMoAutoMap::GetTrackingLayer()
{
	LPDISPATCH pDispatch;
	GetProperty(0x9, VT_DISPATCH, (void*)&pDispatch);
	return CMoTrackingLayer(pDispatch);
}

void CMoAutoMap::SetTrackingLayer(LPDISPATCH propVal)
{
	SetProperty(0x9, VT_DISPATCH, propVal);
}

long CMoAutoMap::GetRefreshCount()
{
	long result;
	GetProperty(0xa, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetRefreshCount(long propVal)
{
	SetProperty(0xa, VT_I4, propVal);
}

BOOL CMoAutoMap::GetEnabled()
{
	BOOL result;
	GetProperty(DISPID_ENABLED, VT_BOOL, (void*)&result);
	return result;
}

void CMoAutoMap::SetEnabled(BOOL propVal)
{
	SetProperty(DISPID_ENABLED, VT_BOOL, propVal);
}

OLE_HANDLE CMoAutoMap::GetHWnd()
{
	OLE_HANDLE result;
	GetProperty(DISPID_HWND, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetHWnd(OLE_HANDLE propVal)
{
	SetProperty(DISPID_HWND, VT_I4, propVal);
}

short CMoAutoMap::GetAppearance()
{
	short result;
	GetProperty(DISPID_APPEARANCE, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetAppearance(short propVal)
{
	SetProperty(DISPID_APPEARANCE, VT_I4, propVal);
}

double CMoAutoMap::GetMinWidth()
{
	double result;
	GetProperty(0x1, VT_R8, (void*)&result);
	return result;
}

void CMoAutoMap::SetMinWidth(double propVal)
{
	SetProperty(0x1, VT_R8, propVal);
}

long CMoAutoMap::GetMousePointer()
{
	long result;
	GetProperty(0xb, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetMousePointer(long propVal)
{
	SetProperty(0xb, VT_I4, propVal);
}

BOOL CMoAutoMap::GetFullRedrawOnPan()
{
	BOOL result;
	GetProperty(0x3, VT_BOOL, (void*)&result);
	return result;
}

void CMoAutoMap::SetFullRedrawOnPan(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

VARIANT CMoAutoMap::GetCoordinateSystem()
{
	VARIANT result;
	GetProperty(0xc, VT_VARIANT, (void*)&result);
	return result;
}

void CMoAutoMap::SetCoordinateSystem(const VARIANT& propVal)
{
	SetProperty(0xc, VT_VARIANT, &propVal);
}

long CMoAutoMap::GetMaxFileBuffer()
{
	long result;
	GetProperty(0xd, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetMaxFileBuffer(long propVal)
{
	SetProperty(0xd, VT_I4, propVal);
}

long CMoAutoMap::GetWindowMode()
{
	long result;
	GetProperty(0xe, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetWindowMode(long propVal)
{
	SetProperty(0xe, VT_I4, propVal);
}

double CMoAutoMap::GetRotationAngle()
{
	double result;
	GetProperty(0xf, VT_R8, (void*)&result);
	return result;
}

void CMoAutoMap::SetRotationAngle(double propVal)
{
	SetProperty(0xf, VT_R8, propVal);
}

LPDISPATCH CMoAutoMap::GetVisibleRegion()
{
	LPDISPATCH result;
	GetProperty(0x10, VT_DISPATCH, (void*)&result);
	return result;
}

void CMoAutoMap::SetVisibleRegion(LPDISPATCH propVal)
{
	SetProperty(0x10, VT_DISPATCH, propVal);
}

long CMoAutoMap::GetGeometryEnvironment()
{
	long result;
	GetProperty(0x2b, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetGeometryEnvironment(long propVal)
{
	SetProperty(0x2b, VT_I4, propVal);
}

long CMoAutoMap::GetDisplayUnit()
{
	long result;
	GetProperty(0x2c, VT_I4, (void*)&result);
	return result;
}

void CMoAutoMap::SetDisplayUnit(long propVal)
{
	SetProperty(0x2c, VT_I4, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// CMoAutoMap operations

void CMoAutoMap::AboutBox()
{
	InvokeHelper(0xfffffdd8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void CMoAutoMap::Pan()
{
	InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

CMoPoint CMoAutoMap::ToMapPoint(float X, float Y)
{
	LPDISPATCH pDispatch;
	static BYTE parms[] =
		VTS_R4 VTS_R4;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
		X, Y);
	return CMoPoint(pDispatch);
}

void CMoAutoMap::FlashShape(LPDISPATCH shape, short nTimes)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_I2;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 shape, nTimes);
}

void CMoAutoMap::Refresh()
{
	InvokeHelper(DISPID_REFRESH, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void CMoAutoMap::DrawShape(LPDISPATCH shape, LPDISPATCH Symbol)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 shape, Symbol);
}

void CMoAutoMap::DrawText(LPCTSTR text, LPDISPATCH shape, LPDISPATCH Symbol)
{
	static BYTE parms[] =
		VTS_BSTR VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 text, shape, Symbol);
}

CMoEllipse CMoAutoMap::TrackCircle()
{
	LPDISPATCH pDispatch;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
	return CMoEllipse(pDispatch);
}

CMoLine CMoAutoMap::TrackLine()
{
	LPDISPATCH pDispatch;
	InvokeHelper(0x17, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
	return CMoLine(pDispatch);
}

CMoRectangle CMoAutoMap::TrackRectangle()
{
	LPDISPATCH pDispatch;
	InvokeHelper(0x18, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
	return CMoRectangle(pDispatch);
}

void CMoAutoMap::FromMapPoint(LPDISPATCH Point, float* X, float* Y)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_PR4 VTS_PR4;
	InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Point, X, Y);
}

double CMoAutoMap::ToMapDistance(float distance)
{
	double result;
	static BYTE parms[] =
		VTS_R4;
	InvokeHelper(0x1a, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
		distance);
	return result;
}

float CMoAutoMap::FromMapDistance(double distance)
{
	float result;
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x1b, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
		distance);
	return result;
}

CMoPolygon CMoAutoMap::TrackPolygon()
{
	LPDISPATCH pDispatch;
	InvokeHelper(0x1c, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
	return CMoPolygon(pDispatch);
}

void CMoAutoMap::OutputMap(long hDC)
{
	static BYTE parms[] =
		VTS_I4;
	InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 hDC);
}

void CMoAutoMap::PrintMap(LPCTSTR docName, LPCTSTR outputFile, BOOL landscapeOrientation)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BOOL;
	InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 docName, outputFile, landscapeOrientation);
}

void CMoAutoMap::ExportMap(long exportType, LPCTSTR outputFile, double scaleFactor)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_R8;
	InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 exportType, outputFile, scaleFactor);
}

void CMoAutoMap::CopyMap(double scaleFactor)
{
	static BYTE parms[] =
		VTS_R8;
	InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 scaleFactor);
}

void CMoAutoMap::CenterAt(double X, double Y)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8;
	InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y);
}

void CMoAutoMap::RefreshLayer(short index, const VARIANT& rect)
{
	static BYTE parms[] =
		VTS_I2 VTS_VARIANT;
	InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 index, &rect);
}

void CMoAutoMap::ExportMap2(long exportType, LPCTSTR outputFile, double scaleFactor, const VARIANT& useSourceDepth)
{
	static BYTE parms[] =
		VTS_I4 VTS_BSTR VTS_R8 VTS_VARIANT;
	InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 exportType, outputFile, scaleFactor, &useSourceDepth);
}

void CMoAutoMap::OutputMap2(long hDC, long X, long Y, long Width, long Height, const VARIANT& DrawFlags)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_VARIANT;
	InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 hDC, X, Y, Width, Height, &DrawFlags);
}

void CMoAutoMap::RefreshRect(LPDISPATCH rect)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 rect);
}

void CMoAutoMap::EnableTIFFLZW(LPCTSTR licenseCode)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 licenseCode);
}

void CMoAutoMap::EnableGIF(LPCTSTR licenseCode)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 licenseCode);
}

void CMoAutoMap::EnableStreetMap(LPCTSTR licenseCode)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x28, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 licenseCode);
}

void CMoAutoMap::ExportMapToJpeg(LPCTSTR outputFile, long percentQuality, BOOL isProgressive, double scaleFactor, long scaleSymbology)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I4 VTS_BOOL VTS_R8 VTS_I4;
	InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 outputFile, percentQuality, isProgressive, scaleFactor, scaleSymbology);
}

void CMoAutoMap::ExportMap3(long formatType, const VARIANT& formatData, double scaleFactor, long scaleSymbology, long exportDepth, long palette)
{
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_R8 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 formatType, &formatData, scaleFactor, scaleSymbology, exportDepth, palette);
}