void CMapX::PrintMap(long hDC, long X, long Y, long W, long H)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
	InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 hDC, X, Y, W, H);
}

void CMapX::ExportMap(LPCTSTR Destination, short Format, const VARIANT& Width, const VARIANT& Height)
{
	static BYTE parms[] =
		VTS_BSTR VTS_I2 VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Destination, Format, &Width, &Height);
}

void CMapX::PropertyPage()
{
	InvokeHelper(0x28, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void CMapX::ConvertCoordV(VARIANT* ScreenX, VARIANT* ScreenY, VARIANT* MapX, VARIANT* MapY, short Direction)
{
	static BYTE parms[] =
		VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_I2;
	InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ScreenX, ScreenY, MapX, MapY, Direction);
}

void CMapX::SetSize(long Width, long Height)
{
	static BYTE parms[] =
		VTS_I4 VTS_I4;
	InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Width, Height);
}

BOOL CMapX::IsPointVisible(double X, double Y)
{
	BOOL result;
	static BYTE parms[] =
		VTS_R8 VTS_R8;
	InvokeHelper(0x2b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		X, Y);
	return result;
}

BOOL CMapX::ClipLine(double* X1, double* Y1, double* X2, double* Y2)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8;
	InvokeHelper(0x2c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		X1, Y1, X2, Y2);
	return result;
}

BOOL CMapX::ClipLineV(VARIANT* X1, VARIANT* Y1, VARIANT* X2, VARIANT* Y2)
{
	BOOL result;
	static BYTE parms[] =
		VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
	InvokeHelper(0x2d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		X1, Y1, X2, Y2);
	return result;
}

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

void CMapX::SaveMapAsGeoset(LPCTSTR Name, LPCTSTR Filespec)
{
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR;
	InvokeHelper(0x2f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		Name, Filespec);
}

LPDISPATCH CMapX::GetDispatch(BOOL bAddRef)
{
	LPUNKNOWN pUnk = GetControlUnknown();
	LPDISPATCH pDispatch;

	if ((pUnk != NULL) &&	SUCCEEDED(pUnk->QueryInterface(IID_IDispatch, (LPVOID*)&pDispatch))) {
		ASSERT(pDispatch != NULL);
		if (!bAddRef) {
			pDispatch->Release();
		}
		return pDispatch;
	}
	return NULL;
}

void CMapX::Pan(float ScreenX, float ScreenY)
{
	static BYTE parms[] =
		VTS_R4 VTS_R4;
	InvokeHelper(0x40, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 ScreenX, ScreenY);
}

/////////////////////////////////////////////////////////////////////////////
// CMapXDatasets properties

LPENUMVARIANT CMapXDatasets::GetEnumerator()
{
	LPENUMVARIANT pEnumVariant = 0;
	LPUNKNOWN pUnknown = 0;
	GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);	
	if(pUnknown)
	{
		pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
		pUnknown->Release();
	}	
	return pEnumVariant;
}

long CMapXDatasets::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

BOOL CMapXDatasets::GetBuildSourceRows()
{
 	BOOL result;
	GetProperty(0x7, VT_BOOL, &result);
	return result;
}

void CMapXDatasets::SetBuildSourceRows(BOOL b)
{
	SetProperty(0x7, VT_BOOL, b);
}

/////////////////////////////////////////////////////////////////////////////
// CMapXDatasets operations

CMapXDataset CMapXDatasets::Add(long Type, const VARIANT& SourceData, const VARIANT& Name, const VARIANT& GeoField, const VARIANT& SecondaryGeoField, const VARIANT& BindLayer, const VARIANT& Fields, const VARIANT& Dynamic)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Type, &SourceData, &Name, &GeoField, &SecondaryGeoField, &BindLayer, &Fields, &Dynamic);
	return CMapXDataset(result);
}

CMapXDataset CMapXDatasets::Item(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return CMapXDataset(result);
}

void CMapXDatasets::Remove(const VARIANT& Index)
{
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &Index);
}

CMapXDataset CMapXDatasets::Restore(LPCTSTR Name, const VARIANT& SourceData)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_VARIANT;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Name, &SourceData);
	return CMapXDataset(result);
}

void CMapXDatasets::RemoveAll()
{
	InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

/////////////////////////////////////////////////////////////////////////////
// CMapXLayers properties

LPENUMVARIANT CMapXLayers::GetEnumerator()
{
	LPENUMVARIANT pEnumVariant = 0;
	LPUNKNOWN pUnknown = 0;
	GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);	
	if(pUnknown)
	{
		pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
		pUnknown->Release();
	}	
	return pEnumVariant;
}

long CMapXLayers::GetCount()
{
	long result;
	GetProperty(0x1, VT_I4, (void*)&result);
	return result;
}

/////////////////////////////////////////////////////////////////////////////
// CMapXLayers operations

void CMapXLayers::ClearSelection()
{
	InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

BOOL CMapXLayers::Move(short From, short To)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I2 VTS_I2;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		From, To);
	return result;
}

CMapXLayer CMapXLayers::Add(const VARIANT& LayerInfo, const VARIANT& Position)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&LayerInfo, &Position);
	return CMapXLayer(result);
}

void CMapXLayers::AddGeoSetLayers(LPCTSTR GeoSetName)
{
	static BYTE parms[] =
		VTS_BSTR;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 GeoSetName);
}

CMapXLayer CMapXLayers::Item(const VARIANT& Index)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Index);
	return CMapXLayer(result);
}

void CMapXLayers::Remove(const VARIANT& Index)
{
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &Index);
}

CMapXLayer CMapXLayers::AddUserDrawLayer(LPCTSTR Name, short Position)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_I2;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Name, Position);
	return CMapXLayer(result);
}

CMapXLayer CMapXLayers::GetAnimationLayer()
{
	LPDISPATCH result;
	GetProperty(0x9, VT_DISPATCH, (void*)&result);
	return CMapXLayer(result);
}

void CMapXLayers::SetAnimationLayer(LPDISPATCH propVal)
{
	SetProperty(0x9, VT_DISPATCH, propVal);
}

CMapXRectangle CMapXLayers::GetBounds()
{
	LPDISPATCH result;
	GetProperty(0xc, VT_DISPATCH, (void*)&result);
	return CMapXRectangle(result);
}

CMapXLayer CMapXLayers::CreateLayer(LPCTSTR Name, const VARIANT& Filespec, const VARIANT& Position, const VARIANT& KeyLength, const VARIANT& CoordSys)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Name, &Filespec, &Position, &KeyLength, &CoordSys);
	return CMapXLayer(result);
}

BOOL CMapXLayers::LayersDlg(const VARIANT& HelpFile, const VARIANT& HelpID)
{
	BOOL result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		&HelpFile, &HelpID);
	return result;
}

CMapXLayer CMapXLayers::AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query, const VARIANT& Position, const VARIANT& Options)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_BSTR VTS_BSTR VTS_BSTR VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Name, ConnectString, Query, &Position, &Options);
	return CMapXLayer(result);
}

void CMapXLayers::RemoveAll()
{
	InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


CMapXLayer CMapXLayers::GetInsertionLayer()
{
	LPDISPATCH pDispatch;
	GetProperty(0xf, VT_DISPATCH, (void*)&pDispatch);
	return CMapXLayer(pDispatch);
}

void CMapXLayers::SetInsertionLayer(LPDISPATCH propVal)
{
	SetProperty(0xf, VT_DISPATCH, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// CMapXLayer properties

CString CMapXLayer::GetName()
{
	CString result;
	GetProperty(0x1, VT_BSTR, (void*)&result);
	return result;
}

void CMapXLayer::SetName(LPCTSTR propVal)
{
	SetProperty(0x1, VT_BSTR, propVal);
}

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

void CMapXLayer::SetVisible(BOOL propVal)
{
	SetProperty(0x2, VT_BOOL, propVal);
}

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

void CMapXLayer::SetSelectable(BOOL propVal)
{
	SetProperty(0x3, VT_BOOL, propVal);
}

CString CMapXLayer::GetFilespec()
{
	CString result;
	GetProperty(0x4, VT_BSTR, (void*)&result);
	return result;
}

CMapXLabelProperties CMapXLayer::GetLabelProperties()
{
	LPDISPATCH result;
	GetProperty(0x5, VT_DISPATCH, (void*)&result);
	return CMapXLabelProperties(result);
}

BOOL CMapXLayer::GetAutoLabel()
{
	BOOL result;
	GetProperty(0x6, VT_BOOL, (void*)&result);
	return result;
}

void CMapXLayer::SetAutoLabel(BOOL propVal)
{
	SetProperty(0x6, VT_BOOL, propVal);
}

BOOL CMapXLayer::GetZoomLayer()
{
	BOOL result;
	GetProperty(0x7, VT_BOOL, (void*)&result);
	return result;
}

void CMapXLayer::SetZoomLayer(BOOL propVal)
{
	SetProperty(0x7, VT_BOOL, propVal);
}

BOOL CMapXLayer::GetOverrideStyle()
{
	BOOL result;
	GetProperty(0x8, VT_BOOL, (void*)&result);
	return result;
}

void CMapXLayer::SetOverrideStyle(BOOL propVal)
{
	SetProperty(0x8, VT_BOOL, propVal);
}

CMapXStyle CMapXLayer::GetStyle()
{
	LPDISPATCH result;
	GetProperty(0x9, VT_DISPATCH, (void*)&result);
	return CMapXStyle(result);
}

void CMapXLayer::SetStyle(LPDISPATCH propVal)
{
	SetProperty(0x9, VT_DISPATCH, propVal);
}

double CMapXLayer::GetZoomMin()
{
	double result;
	GetProperty(0xa, VT_R8, (void*)&result);
	return result;
}

void CMapXLayer::SetZoomMin(double propVal)
{
	SetProperty(0xa, VT_R8, propVal);
}

double CMapXLayer::GetZoomMax()
{
	double result;
	GetProperty(0xb, VT_R8, (void*)&result);
	return result;
}

void CMapXLayer::SetZoomMax(double propVal)
{
	SetProperty(0xb, VT_R8, propVal);
}

CMapXSelection CMapXLayer::GetSelection()
{
	LPDISPATCH result;
	GetProperty(0xc, VT_DISPATCH, (void*)&result);
	return CMapXSelection(result);
}

short CMapXLayer::GetPredominantFeatureType()
{
	short result;
	GetProperty(0xd, VT_I2, (void*)&result);
	return result;
}

CMapXLayerFind CMapXLayer::GetFind()
{
	LPDISPATCH result;
	GetProperty(0xe, VT_DISPATCH, (void*)&result);
	return CMapXLayerFind(result);
}

short CMapXLayer::GetType()
{
	short result;
	GetProperty(0xf, VT_I2, (void*)&result);
	return result;
}

CString CMapXLayer::GetKeyField()
{
	CString result;
	GetProperty(0x10, VT_BSTR, (void*)&result);
	return result;
}

void CMapXLayer::SetKeyField(LPCTSTR propVal)
{
	SetProperty(0x10, VT_BSTR, propVal);
}

CMapXCoordSys CMapXLayer::GetCoordSys()
{
	LPDISPATCH result;
	GetProperty(0x11, VT_DISPATCH, (void*)&result);
	return CMapXCoordSys(result);
}

CMapXRectangle CMapXLayer::GetBounds()
{
	LPDISPATCH result;
	GetProperty(0x20, VT_DISPATCH, (void*)&result);
	return CMapXRectangle(result);
}

BOOL CMapXLayer::GetDrawLabelsAfter()
{
	BOOL result;
	GetProperty(0x25, VT_BOOL, (void*)&result);
	return result;
}

void CMapXLayer::SetDrawLabelsAfter(BOOL propVal)
{
	SetProperty(0x25, VT_BOOL, propVal);
}

CMapXDatasets CMapXLayer::GetDatasets()
{
	LPDISPATCH result;
	GetProperty(0x27, VT_DISPATCH, (void*)&result);
	return CMapXDatasets(result);
}

BOOL CMapXLayer::GetShowNodes()
{
	BOOL result;
	GetProperty(0x2b, VT_BOOL, (void*)&result);
	return result;
}

void CMapXLayer::SetShowNodes(BOOL propVal)
{
	SetProperty(0x2b, VT_BOOL, propVal);
}

BOOL CMapXLayer::GetShowCentroids()
{
	BOOL result;
	GetProperty(0x2c, VT_BOOL, (void*)&result);
	return result;
}

void CMapXLayer::SetShowCentroids(BOOL propVal)
{
	SetProperty(0x2c, VT_BOOL, propVal);
}

BOOL CMapXLayer::GetShowLineDirection()
{
	BOOL result;
	GetProperty(0x2d, VT_BOOL, (void*)&result);
	return result;
}

void CMapXLayer::SetShowLineDirection(BOOL propVal)
{
	SetProperty(0x2d, VT_BOOL, propVal);
}

BOOL CMapXLayer::GetEditable()
{
	BOOL result;
	GetProperty(0x2e, VT_BOOL, (void*)&result);
	return result;
}

void CMapXLayer::SetEditable(BOOL propVal)
{
	SetProperty(0x2e, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// CMapXLayer operations

void CMapXLayer::LabelAtPoint(double X, double Y)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y);
}