?? mapx.cpp

?? MapX控件的使用
?? CPP
?? 第 1 頁 / 共 5 頁
字號:
上一頁 1 2 3 45
{
	SetProperty(0x1c, VT_DISPATCH, propVal);
}

BOOL CMapXThemeProperties::GetPieGraduated()
{
	BOOL result;
	GetProperty(0x1d, VT_BOOL, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetPieGraduated(BOOL propVal)
{
	SetProperty(0x1d, VT_BOOL, propVal);
}

BOOL CMapXThemeProperties::GetBarGraduatedStack()
{
	BOOL result;
	GetProperty(0x1e, VT_BOOL, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetBarGraduatedStack(BOOL propVal)
{
	SetProperty(0x1e, VT_BOOL, propVal);
}

short CMapXThemeProperties::GetApplyAttribute()
{
	short result;
	GetProperty(0x1f, VT_I2, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetApplyAttribute(short propVal)
{
	SetProperty(0x1f, VT_I2, propVal);
}

BOOL CMapXThemeProperties::GetRoundRanges()
{
	BOOL result;
	GetProperty(0x20, VT_BOOL, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetRoundRanges(BOOL propVal)
{
	SetProperty(0x20, VT_BOOL, propVal);
}

double CMapXThemeProperties::GetRoundBy()
{
	double result;
	GetProperty(0x21, VT_R8, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetRoundBy(double propVal)
{
	SetProperty(0x21, VT_R8, propVal);
}

short CMapXThemeProperties::GetColorMethod()
{
	short result;
	GetProperty(0x22, VT_I2, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetColorMethod(short propVal)
{
	SetProperty(0x22, VT_I2, propVal);
}

BOOL CMapXThemeProperties::GetInflectRanges()
{
	BOOL result;
	GetProperty(0x23, VT_BOOL, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetInflectRanges(BOOL propVal)
{
	SetProperty(0x23, VT_BOOL, propVal);
}

short CMapXThemeProperties::GetInflectionRange()
{
	short result;
	GetProperty(0x24, VT_I2, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetInflectionRange(short propVal)
{
	SetProperty(0x24, VT_I2, propVal);
}

unsigned long CMapXThemeProperties::GetInflectionColor()
{
	unsigned long result;
	GetProperty(0x25, VT_I4, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetInflectionColor(unsigned long propVal)
{
	SetProperty(0x25, VT_I4, propVal);
}

BOOL CMapXThemeProperties::GetBarFramed()
{
	BOOL result;
	GetProperty(0x26, VT_BOOL, (void*)&result);
	return result;
}

void CMapXThemeProperties::SetBarFramed(BOOL propVal)
{
	SetProperty(0x26, VT_BOOL, propVal);
}

/////////////////////////////////////////////////////////////////////////////
// CMapXThemeProperties operations


/////////////////////////////////////////////////////////////////////////////
// CMapXSelection properties

LPENUMVARIANT CMapXSelection::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 CMapXSelection::GetCount()
{
	long result;
	GetProperty(0x10001, VT_I4, (void*)&result);
	return result;
}

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

/////////////////////////////////////////////////////////////////////////////
// CMapXSelection operations

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

CMapXFeatures CMapXSelection::Clone()
{
	LPDISPATCH result;
	InvokeHelper(0x10003, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return CMapXFeatures(result);
}

void CMapXSelection::Add(LPDISPATCH Source)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x10004, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Source);
}

void CMapXSelection::Common(LPDISPATCH Source)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x10005, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Source);
}

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

void CMapXSelection::Replace(LPDISPATCH Source)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x10007, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Source);
}

void CMapXSelection::AddByID(const VARIANT& FeatureID)
{
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x10009, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &FeatureID);
}

void CMapXSelection::RemoveByID(const VARIANT& FeatureID)
{
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x1000a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &FeatureID);
}

void CMapXSelection::SelectByRegion(LPDISPATCH Layer, const VARIANT& FeatureID, short Flag)
{
	static BYTE parms[] =
		VTS_DISPATCH VTS_VARIANT VTS_I2;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 Layer, &FeatureID, Flag);
}

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

void CMapXSelection::SelectByPoint(double X, double Y, short Flag)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_I2;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, Flag);
}

void CMapXSelection::SelectByRadius(double X, double Y, double radius, short Flag)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_I2;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X, Y, radius, Flag);
}

void CMapXSelection::SelectByRectangle(double X1, double Y1, double X2, double Y2, short Flag)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_I2;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 X1, Y1, X2, Y2, Flag);
}

BOOL CMapXSelection::SelectAll(short Flag)
{
	BOOL result;
	static BYTE parms[] =
		VTS_I2;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
		Flag);
	return result;
}

void CMapXSelection::SelectByID(const VARIANT& FeatureID, short Flag)
{
	static BYTE parms[] =	
		VTS_VARIANT VTS_I2;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 &FeatureID, Flag);
}


/////////////////////////////////////////////////////////////////////////////
// CMapXFeature properties

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

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

void CMapXFeature::SetType(short propVal)
{
	SetProperty(0x2, VT_I2, propVal);
}

double CMapXFeature::GetLength()
{
	double result;
	GetProperty(0x3, VT_R8, (void*)&result);
	return result;
}

double CMapXFeature::GetCenterX()
{
	double result;
	GetProperty(0x4, VT_R8, (void*)&result);
	return result;
}

double CMapXFeature::GetCenterY()
{
	double result;
	GetProperty(0x5, VT_R8, (void*)&result);
	return result;
}

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

void CMapXFeature::SetStyle(LPDISPATCH propVal)
{
	SetProperty(0x6, VT_DISPATCH, propVal);
}

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

CString CMapXFeature::GetCaption()
{
	CString result;
	GetProperty(0x8, VT_BSTR, (void*)&result);
	return result;
}

void CMapXFeature::SetCaption(LPCTSTR propVal)
{
	SetProperty(0x8, VT_BSTR, propVal);
}

CMapXParts CMapXFeature::GetParts()
{
	LPDISPATCH result;
	GetProperty(0x9, VT_DISPATCH, (void*)&result);
	return CMapXParts(result);
}

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

CMapXLayer CMapXFeature::GetLayer()
{
	LPDISPATCH result;
	GetProperty(0xb, VT_DISPATCH, (void*)&result);
	return CMapXLayer(result);
}

CMapXPoint CMapXFeature::GetPoint()
{
	LPDISPATCH result;
	GetProperty(0xc, VT_DISPATCH, (void*)&result);
	return CMapXPoint(result);
}

void CMapXFeature::SetPoint(LPDISPATCH propVal)
{
	SetProperty(0xc, VT_DISPATCH, propVal);
}

CMapXPoint CMapXFeature::GetLabelPoint()
{
	LPDISPATCH result;
	GetProperty(0xd, VT_DISPATCH, (void*)&result);
	return CMapXPoint(result);
}

double CMapXFeature::GetPerimeter()
{
	double result;
	GetProperty(0xe, VT_R8, (void*)&result);
	return result;
}

BOOL CMapXFeature::GetSmooth()
{
	BOOL result;
	GetProperty(0xf, VT_BOOL, (void*)&result);
	return result;
}

void CMapXFeature::SetSmooth(BOOL propVal)
{
	SetProperty(0xf, VT_BOOL, propVal);
}

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

CString CMapXFeature::GetKeyValue()
{
	CString result;
	GetProperty(0x11, VT_BSTR, (void*)&result);
	return result;
}

void CMapXFeature::SetKeyValue(LPCTSTR propVal)
{
	SetProperty(0x11, VT_BSTR, propVal);
}

CString CMapXFeature::GetFeatureKey()
{
	CString result;
	GetProperty(0x17, VT_BSTR, (void*)&result);
	return result;
}

/////////////////////////////////////////////////////////////////////////////
// CMapXFeature operations

void CMapXFeature::Update(const VARIANT& UpdateFeature, const VARIANT& RowValues)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms, &UpdateFeature, &RowValues);
}

void CMapXFeature::Offset(double deltaX, double deltaY)
{
	static BYTE parms[] =
		VTS_R8 VTS_R8;
	InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
		 deltaX, deltaY);
}

void CMapXFeature::Attach(LPDISPATCH Map)
{
	static BYTE parms[] =
		VTS_DISPATCH;
	InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms, Map);
}

CMapXFeature CMapXFeature::Clone()
{
	LPDISPATCH result;
	InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
	return CMapXFeature(result);
}

VARIANT CMapXFeature::Nodes(const VARIANT& CSys)
{
	VARIANT result;
	static BYTE parms[] =	VTS_VARIANT;
	InvokeHelper(0x16, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &CSys);
	return result;
}

VARIANT CMapXFeature::GetNodes(const VARIANT& CSys)
{
	VARIANT result;
	static BYTE parms[] =
		VTS_VARIANT;
	InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
		&CSys);
	return result;
}

void CMapXFeature::SetNodes(const VARIANT& CSys, const VARIANT& newValue)
{
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
		 &CSys, &newValue);
}

/////////////////////////////////////////////////////////////////////////////
// CMapXFeatureFactory properties

/////////////////////////////////////////////////////////////////////////////
// CMapXFeatureFactory operations

CMapXFeature CMapXFeatureFactory::BufferFeatures(LPDISPATCH Source, double Distance, const VARIANT& Units, const VARIANT& Resolution)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_R8 VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Source, Distance, &Units, &Resolution);
	return CMapXFeature(result);
}

CMapXFeature CMapXFeatureFactory::CombineFeatures(LPDISPATCH Source1, const VARIANT& Source2)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_VARIANT;
	InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Source1, &Source2);
	return CMapXFeature(result);
}

CMapXFeature CMapXFeatureFactory::IntersectFeatures(LPDISPATCH Source1, const VARIANT& Source2)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_VARIANT;
	InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Source1, &Source2);
	return CMapXFeature(result);
}

CMapXFeature CMapXFeatureFactory::EraseFeature(LPDISPATCH Feature, LPDISPATCH EraserFeature)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH;
	InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Feature, EraserFeature);
	return CMapXFeature(result);
}

CMapXFeature CMapXFeatureFactory::CreateSymbol(const VARIANT& Point, const VARIANT& Style)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Point, &Style);
	return CMapXFeature(result);
}

CMapXFeature CMapXFeatureFactory::CreateRegion(const VARIANT& Points, const VARIANT& Style)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Points, &Style);
	return CMapXFeature(result);
}

CMapXFeature CMapXFeatureFactory::CreateLine(const VARIANT& Points, const VARIANT& Style)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Points, &Style);
	return CMapXFeature(result);
}

CMapXFeature CMapXFeatureFactory::CreateText(const VARIANT& Point, const VARIANT& Caption, const VARIANT& Position, const VARIANT& Style)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		&Point, &Caption, &Position, &Style);
	return CMapXFeature(result);
}

CMapXFeature CMapXFeatureFactory::CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, const VARIANT& Angle, const VARIANT& Distance, const VARIANT& Resolution, const VARIANT& Style)
{
	LPDISPATCH result;
	static BYTE parms[] =
		VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
	InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
		Point1, Point2, &Angle
上一頁 1 2 3 45
?? 文件大小 303 K
?? 上傳用戶 epower
?? 所屬分類 GPS編程
??? 相關(guān)標(biāo)簽

#MapX #控件
?? 快捷鍵說明

復(fù)制代碼 Ctrl + C
搜索代碼 Ctrl + F
全屏模式 F11
切換主題 Ctrl + Shift + D
顯示快捷鍵 ?
增大字號 Ctrl + =
減小字號 Ctrl + -
亚洲欧美第一页_禁久久精品乱码_粉嫩av一区二区三区免费野_久草精品视频

?? mapx.cpp

?? 快捷鍵說明
