mapx.h

采用apx开发GPS车辆监控的源码

	CString GetKeyField();
	void SetKeyField(LPCTSTR);
	CMapXCoordSys GetCoordSys();
	CMapXRectangle GetBounds();
	BOOL GetDrawLabelsAfter();
	void SetDrawLabelsAfter(BOOL);
	CMapXDatasets GetDatasets();
	BOOL GetShowNodes();
	void SetShowNodes(BOOL propVal);
	BOOL GetShowCentroids();
	void SetShowCentroids(BOOL propVal);
	BOOL GetShowLineDirection();
	void SetShowLineDirection(BOOL propVal);
	BOOL GetEditable();
	void SetEditable(BOOL propVal);

// Operations
public:
	void LabelAtPoint(double X, double Y);
	void ClearCustomLabels();
	
	CMapXFeature AddFeature(LPDISPATCH Source, const VARIANT& RowValues);
	CMapXFeature AddFeature(LPDISPATCH Source)
	{ return AddFeature(Source, COptionalVariant()); }
	CMapXFeature AddFeature(LPDISPATCH Source, LPDISPATCH RowValues)
	{
		return AddFeature(Source, COleVariantDispatch(RowValues));
	}

	void UpdateFeature(const VARIANT& Target, const VARIANT& Source, const VARIANT& RowValues);
	void UpdateFeature(LPDISPATCH Target, LPDISPATCH Source, LPDISPATCH RowValues)
	{
		UpdateFeature(COleVariantDispatch(Target), COleVariantDispatch(Source), COleVariantDispatch(RowValues));
	}
	void UpdateFeature(LPCTSTR Target, LPDISPATCH Source, LPDISPATCH RowValues)
	{
		UpdateFeature(COleVariant(Target), COleVariantDispatch(Source), COleVariantDispatch(RowValues));
	}
	void UpdateFeature(long Target, LPDISPATCH Source, LPDISPATCH RowValues)
	{
		UpdateFeature(COleVariant(Target), COleVariantDispatch(Source), COleVariantDispatch(RowValues));
	}
	void UpdateFeature(LPDISPATCH Target, LPDISPATCH Source)
	{
		UpdateFeature(COleVariantDispatch(Target), COleVariantDispatch(Source), COptionalVariant());
	}
	void UpdateFeature(LPCTSTR Target, LPDISPATCH Source)
	{
		UpdateFeature(COleVariant(Target), COleVariantDispatch(Source), COptionalVariant());
	}
	void UpdateFeature(long Target, LPDISPATCH Source)
	{
		UpdateFeature(COleVariant(Target), COleVariantDispatch(Source), COptionalVariant());
	}
	void UpdateFeature(LPDISPATCH Target)
	{
		UpdateFeature(COleVariantDispatch(Target), COptionalVariant(), COptionalVariant());
	}
	void UpdateFeature(LPCTSTR Target)
	{ UpdateFeature(COleVariant(Target), COptionalVariant(), COptionalVariant()); }
	void UpdateFeature(long Target)
	{ UpdateFeature(COleVariant(Target), COptionalVariant(), COptionalVariant()); }

	void DeleteFeature(const VARIANT& Target);
	void DeleteFeature(LPDISPATCH Target)
	{
		DeleteFeature(COleVariantDispatch(Target));
	}
	void DeleteFeature(LPCTSTR Target)
	{ DeleteFeature(COleVariant(Target)); }
	void DeleteFeature(long Target)
	{ DeleteFeature(COleVariant(Target)); }

	void Invalidate(const VARIANT& InvalidRect);
	void Invalidate() { Invalidate(COptionalVariant()); }
	CMapXFeatures SearchWithinDistance(LPDISPATCH Source, double Distance, short Units, short SearchType);
	CMapXFeatures SearchWithinRectangle(LPDISPATCH Rectangle, short SearchType);
	CMapXFeatures AllFeatures();
	CMapXFeatures NoFeatures();
	CMapXFeatures SearchWithinFeature(LPDISPATCH Feature, short SearchType);
	CMapXFeatures SearchAtPoint(LPDISPATCH Point);
	void DrillDownRemoveFeatures(LPCTSTR Level, const VARIANT& FeatureKeys);
	void DrillDownAddFeatures(LPCTSTR Level, const VARIANT& FeatureKeys);
	CMapXFeatures GetDrilldownFeaturesByID(LPCTSTR Level, const VARIANT& FeatureKeys);
	void DrilldownReset(LPCTSTR Level);
	CMapXFeature GetFeatureByID(long FeatureID);
	void Refresh();
	long FeatureIDFromFeatureName(LPCTSTR Name);

	CMapXFeatures Search(LPCTSTR Where, const VARIANT& Variables);
	CMapXFeatures Search(LPCTSTR Where)
		{ return Search(Where, COptionalVariant()); }
	CMapXFeatures Search(LPCTSTR Where, LPDISPATCH Variables)
		{ return Search(Where, COleVariantDispatch(Variables)); }

	void BeginAccess(long BeginAccessType);
	void EndAccess(const VARIANT& EndAccessType);
	void EndAccess()
	{ EndAccess(COptionalVariant()); }

	CMapXFeature GetFeatureByKey(LPCTSTR);
	CString FeatureKeyFromFeatureName(LPCTSTR);
};

class CMapXLayers : public COleDispatchDriver
{
public:
	CMapXLayers() {}		// Calls COleDispatchDriver default constructor
	CMapXLayers(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXLayers(const CMapXLayers& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

	CMapXLayer operator[](long Index) { return Item(Index); }
	CMapXLayer operator[](LPCTSTR Index) { return Item(Index); }

// Attributes
public:
	LPENUMVARIANT GetEnumerator();
	long GetCount();
	
	CMapXLayer GetAnimationLayer();
	void SetAnimationLayer(LPDISPATCH);
	CMapXRectangle GetBounds();
	CMapXLayer GetInsertionLayer();
	void SetInsertionLayer(LPDISPATCH);

// Operations
public:
	void ClearSelection();
	BOOL Move(short From, short To);
	CMapXLayer Add(const VARIANT& LayerInfo, const VARIANT& Position);
	CMapXLayer Add(LPDISPATCH LayerInfo)
	{
		return Add(COleVariantDispatch(LayerInfo), COptionalVariant());
	}
	CMapXLayer Add(LPDISPATCH LayerInfo, long Position)
	{
		return Add(COleVariantDispatch(LayerInfo), COleVariant(Position));
	}
	CMapXLayer Add(LPCTSTR Filespec, const VARIANT& Position)
	{ return Add(COleVariant(Filespec), Position); }
	CMapXLayer Add(LPCTSTR Filespec) // for backward compatiblity
	{ return Add(COleVariant(Filespec), COptionalVariant()); }
	CMapXLayer Add(LPCTSTR Filespec, long Position)
	{ return Add(COleVariant(Filespec), COleVariant(Position)); }

	void AddGeoSetLayers(LPCTSTR GeoSetName);
	CMapXLayer Item(const VARIANT& Index);
	CMapXLayer Item(long Index) { return Item(COleVariant(Index)); }
	CMapXLayer Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
	void Remove(const VARIANT& Index);
	void Remove(long Index) { Remove(COleVariant(Index)); }
	void Remove(LPCTSTR Index) { Remove(COleVariant(Index)); }
	CMapXLayer AddUserDrawLayer(LPCTSTR Name, short Position);
	CMapXLayer CreateLayer(LPCTSTR Name, const VARIANT& Filespec, const VARIANT& Position, const VARIANT& KeyLength, const VARIANT& CoordSys);
	CMapXLayer CreateLayer(LPCTSTR Name, LPCTSTR Filespec=NULL, long Position=-1, short KeyLength=32)
		{ return CreateLayer(Name, COleVariant(Filespec), COleVariant(Position), COleVariant(KeyLength), COptionalVariant()); }
	BOOL LayersDlg(const VARIANT& HelpFile, const VARIANT& HelpID);
	BOOL LayersDlg(LPCTSTR HelpFile, UINT HelpID=HELP_FINDER)
		{ return LayersDlg(COleVariant(HelpFile), COleVariant((long)HelpID)); }
	BOOL LayersDlg()
		{ return LayersDlg(COptionalVariant(), COptionalVariant()); }
	CMapXLayer AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query, const VARIANT& Position, const VARIANT& Options);
	CMapXLayer AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query, long Position, long Options=0)
		{ return AddServerLayer(Name, ConnectString, Query, COleVariant(Position), COleVariant(Options)); }
	CMapXLayer AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query)
		{ return AddServerLayer(Name, ConnectString, Query, COptionalVariant(), COptionalVariant()); }
	void RemoveAll();

};
/////////////////////////////////////////////////////////////////////////////
// CMapXField wrapper class

class CMapXField : public COleDispatchDriver
{
public:
	CMapXField() {}		// Calls COleDispatchDriver default constructor
	CMapXField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXField(const CMapXField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	long GetType();
	CString GetName();
	long GetAggregationFunction();
	short GetWidth();
	short GetPrecision();
	short GetDecimals();

// Operations
public:
};

/////////////////////////////////////////////////////////////////////////////
// CMapXTheme wrapper class

class CMapXTheme : public COleDispatchDriver
{
public:
	CMapXTheme() {}		// Calls COleDispatchDriver default constructor
	CMapXTheme(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXTheme(const CMapXTheme& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	BOOL GetVisible();
	void SetVisible(BOOL);
	short GetType();
	CMapXThemeProperties GetProperties();
	CMapXLegend GetLegend();
	BOOL GetAutoRecompute();
	void SetAutoRecompute(BOOL);
	CString GetName();
	void SetName(LPCTSTR);
	CMapXThemeProperties GetThemeProperties();
	CMapXLayer GetLayer();
	CMapXFields GetFields();
	double GetDataMin();
	void SetDataMin(double);
	double GetDataMax();
	void SetDataMax(double);
	BOOL GetComputeTheme();
	void SetComputeTheme(BOOL);

// Operations
public:
	BOOL ThemeDlg(const VARIANT& HelpFile, const VARIANT& HelpID);
	BOOL ThemeDlg(LPCTSTR HelpFile, UINT HelpID=HELP_FINDER)
		{ return ThemeDlg(COleVariant(HelpFile), COleVariant((long)HelpID)); }
	BOOL ThemeDlg()
		{ return ThemeDlg(COptionalVariant(), COptionalVariant()); }
};

/////////////////////////////////////////////////////////////////////////////
// CMapXThemes wrapper class

class CMapXThemes : public COleDispatchDriver
{
public:
	CMapXThemes() {}		// Calls COleDispatchDriver default constructor
	CMapXThemes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXThemes(const CMapXThemes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

	CMapXTheme operator[](long Index) { return Item(Index); }
	CMapXTheme operator[](LPCTSTR Index) { return Item(Index); }

// Attributes
public:
	LPENUMVARIANT GetEnumerator();
	
	long GetCount();

// Operations
public:
	CMapXTheme Add(const VARIANT& Type, const VARIANT& Field, const VARIANT& Name, const VARIANT& ComputeTheme);
	CMapXTheme Add(const VARIANT& Type, const VARIANT& Field, const VARIANT& Name)
		{ return Add(COleVariant(Type), COleVariant(Field), COleVariant(Name), COptionalVariant()); }
	CMapXTheme Add(short Type, long Field, LPCTSTR Name)
		{ return Add(COleVariant(Type), COleVariant(Field), COleVariant(Name), COptionalVariant()); }
	CMapXTheme Add(short Type, LPCTSTR Field, LPCTSTR Name)
		{ return Add(COleVariant(Type), COleVariant(Field), COleVariant(Name), COptionalVariant()); }
	CMapXTheme Add(short Type, long Field)
		{ return Add(COleVariant(Type), COleVariant(Field), COptionalVariant(), COptionalVariant()); }
	CMapXTheme Add(short Type, LPCTSTR Field)
		{ return Add(COleVariant(Type), COleVariant(Field), COptionalVariant(), COptionalVariant()); }
	CMapXTheme Add(short Type=miThemeAuto)
		{ return Add(COleVariant(Type), COptionalVariant(), COptionalVariant(), COptionalVariant()); }
	CMapXTheme Item(const VARIANT& Index);
	CMapXTheme Item(long Index) { return Item(COleVariant(Index)); }
	CMapXTheme Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
	void Remove(const VARIANT& Index);
	void Remove(long Index) { Remove(COleVariant(Index)); }
	void Remove(LPCTSTR Index) { Remove(COleVariant(Index)); }
	void RemoveAll();
};

/////////////////////////////////////////////////////////////////////////////
// CMapXLegend wrapper class

class CMapXLegend : public COleDispatchDriver
{
public:
	CMapXLegend() {}		// Calls COleDispatchDriver default constructor
	CMapXLegend(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXLegend(const CMapXLegend& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	BOOL GetCompact();
	void SetCompact(BOOL);
	BOOL GetVisible();
	void SetVisible(BOOL);
	CMapXStyle GetTitleStyle();
	void SetTitleStyle(LPDISPATCH);
	CMapXStyle GetSubTitleStyle();
	void SetSubTitleStyle(LPDISPATCH);
	CMapXStyle GetCompactTitleStyle();
	void SetCompactTitleStyle(LPDISPATCH);
	CMapXStyle GetBodyTextStyle();
	void SetBodyTextStyle(LPDISPATCH);
	CMapXLegendTexts GetLegendTexts();
	BOOL GetCurrencyFormat();
	void SetCurrencyFormat(BOOL);
	CString GetTitle();
	void SetTitle(LPCTSTR);
	CString GetSubTitle();
	void SetSubTitle(LPCTSTR);
	CString GetCompactTitle();
	void SetCompactTitle(LPCTSTR);
	double GetLeft();
	void SetLeft(double);
	double GetTop();
	void SetTop(double);
	double GetWidth();
	double GetHeight();
	BOOL GetShowEmptyRanges();
	void SetShowEmptyRanges(BOOL);
	BOOL GetShowCount();
	void SetShowCount(BOOL propVal);
	double GetPaperHeight();
	double GetPaperWidth();
		
// Operations
public:
	BOOL LegendDlg(const VARIANT& HelpFile, const VARIANT& HelpID);
	BOOL LegendDlg(LPCTSTR HelpFile, UINT HelpID=HELP_FINDER)
		{ return LegendDlg(COleVariant(HelpFile), COleVariant((long)HelpID)); }
	BOOL LegendDlg()
		{ return LegendDlg(COptionalVariant(), COptionalVariant()); }
	void ExportLegend(LPCTSTR Destination, short Format);
	void PrintLegend(long hDC, long X, long Y, long W, long H);
};

/////////////////////////////////////////////////////////////////////////////
// CMapXAnnotation wrapper class

class CMapXAnnotation : public COleDispatchDriver
{
public:
	CMapXAnnotation() {}		// Calls COleDispatchDriver default constructor
	CMapXAnnotation(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXAnnotation(const CMapXAnnotation& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	short GetType();
	CMapXGraphic GetGraphic();

// Operations
public:
};

/////////////////////////////////////////////////////////////////////////////
// CMapXAnnotations wrapper class

class CMapXAnnotations : public COleDispatchDriver
{
public:
	CMapXAnnotations() {}		// Calls COleDispatchDriver default constructor
	CMapXAnnotations(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXAnnotations(const CMapXAnnotations& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

	CMapXAnnotation operator[](long Index) { return Item(Index); }
	CMapXAnnotation operator[](LPCTSTR Index) { return Item(Index); }

	// Attributes
public:
	LPENUMVARIANT GetEnumerator();

	BOOL GetEditable();
	void SetEditable(BOOL);
	long GetCount();

// Operations
public:
	
	CMapXAnnotation Item(const VARIANT& Index);
	CMapXAnnotation Item(long Index) { return Item(COleVariant(Index)); }
	CMapXAnnotation Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
	void Remove(const VARIANT& Index);
	void Remove(long Index) { Remove(COleVariant(Index)); }

	CMapXAnnotation AddSymbol(double X, double Y);
	CMapXAnnotation AddText(LPCTSTR Text, double X, double Y, const VARIANT& Position);
	CMapXAnnotation AddText(LPCTSTR Text, double X, double Y, short Position)
		{ return AddText(Text, X, Y, COleVariant(Position)); }

	void RemoveAll();
	CMapXAnnotation ActiveAnnotation();
};

/////////////////////////////////////////////////////////////////////////////
// CMapXThemeProps wrapper class

class CMapXThemeProperties : public COleDispatchDriver
{
public:
	CMapXThemeProperties() {}		// Calls COleDispatchDriver default constructor
	CMapXThemeProperties(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXThemeProperties(const CMapXThemeProperties& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	short GetDistMethod();
	void SetDistMethod(short);
	short GetNumRanges();
	void SetNumRanges(short);
	CMapXRangeCategories GetRangeCategories();
	short GetDotSize();
	void SetDotSize(short);
	BOOL GetGraduated();
	void SetGraduated(BOOL);
	CMapXMultivarCategories GetMultivarCategories();
	BOOL GetIndependent();
	void SetIndependent(BOOL);
	CMapXIndividualValueCategories GetIndividualValueCategories();
	double GetValuePerDot();
	void SetValuePerDot(double);
	double GetDataValue();
	void SetDataValue(double);
	double GetSize();
	void SetSize(double);
	double GetWidth();
	void SetWidth(double);
	CMapXStyle GetSymbolStyle();
	void SetSymbolStyle(LPDISPATCH);
	short GetSpreadBy();
	void SetSpreadBy(short);
	BOOL GetAllowEmptyRanges();
	void SetAllowEmptyRanges(BOOL);
	unsigned long GetDotColor();