mapx.h

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

	void SetDotColor(unsigned long);
	BOOL GetPieClockwise();
	void SetPieClockwise(BOOL);
	BOOL GetPieHalfPies();
	void SetPieHalfPies(BOOL);
	short GetPieStartAngle();
	void SetPieStartAngle(short);
	BOOL GetBarStacked();
	void SetBarStacked(BOOL);
	CMapXStyle GetNegativeSymbolStyle();
	void SetNegativeSymbolStyle(LPDISPATCH);
	BOOL GetShowNegativeValues();
	void SetShowNegativeValues(BOOL);
	short GetGraduateSizeBy();
	void SetGraduateSizeBy(short);
	CMapXStyle GetBorderStyle();
	void SetBorderStyle(LPDISPATCH);
	double GetBarWidth();
	void SetBarWidth(double);
	BOOL GetBarIndependentScale();
	void SetBarIndependentScale(BOOL);
	CMapXStyle GetPositiveSymbolStyle();
	void SetPositiveSymbolStyle(LPDISPATCH);
	CMapXStyle GetBarFrameStyle();
	void SetBarFrameStyle(LPDISPATCH);
	BOOL GetPieGraduated();
	void SetPieGraduated(BOOL);
	BOOL GetBarGraduatedStack();
	void SetBarGraduatedStack(BOOL);
	short GetApplyAttribute();
	void SetApplyAttribute(short);
	BOOL GetRoundRanges();
	void SetRoundRanges(BOOL);
	double GetRoundBy();
	void SetRoundBy(double);
	short GetColorMethod();
	void SetColorMethod(short);
	BOOL GetInflectRanges();
	void SetInflectRanges(BOOL);
	short GetInflectionRange();
	void SetInflectionRange(short);
	unsigned long GetInflectionColor();
	void SetInflectionColor(unsigned long);
	BOOL GetBarFramed();
	void SetBarFramed(BOOL);

// Operations
public:
};

/////////////////////////////////////////////////////////////////////////////
// CMapXSelection wrapper class

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

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

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

// Operations
public:
	void SelectByRegion(LPDISPATCH Layer, const VARIANT& FeatureID, short Flag);
	void SelectByRegion(LPDISPATCH Layer, long FeatureID, short Flag)
	{ SelectByRegion(Layer, COleVariant(FeatureID), Flag); }
	void SelectByRegion(LPDISPATCH Layer, LPCTSTR FeatureID, short Flag)
	{ SelectByRegion(Layer, COleVariant(FeatureID), Flag); }

	void ClearSelection();
	void SelectByPoint(double X, double Y, short Flag);
	void SelectByRadius(double X, double Y, double radius, short Flag);
	void SelectByRectangle(double X1, double Y1, double X2, double Y2, short Flag);
	BOOL SelectAll(short Flag);

	void SelectByID(const VARIANT& FeatureID, short Flag);
	void SelectByID(long FeatureID, short Flag)
	{ SelectByID(COleVariant(FeatureID), Flag); }
	void SelectByID(LPCTSTR FeatureID, short Flag)
	{ SelectByID(COleVariant(FeatureID), Flag); }

	CMapXFeature Item(const VARIANT& Index);
	CMapXFeature Item(long Index) { return Item(COleVariant(Index)); }
	void Remove(const VARIANT& Source);
	void Remove(long Index) { Remove(COleVariant(Index)); }
	void Remove(LPDISPATCH Source=NULL)
	{ Remove(COleVariantDispatch(Source));}
	
	CMapXFeatures Clone();

	void Add(LPDISPATCH Source);
	void Common(LPDISPATCH Source);
	void Replace(LPDISPATCH Source);

	void AddByID(const VARIANT& FeatureID);
	void RemoveByID(const VARIANT& FeatureID);
};

/////////////////////////////////////////////////////////////////////////////
// CMapXRangeCategory wrapper class

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

// Attributes
public:
	double GetMin();
	void SetMin(double);
	double GetMax();
	void SetMax(double);
	long GetNumItems();
	CMapXStyle GetStyle();
	void SetStyle(LPDISPATCH);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// CMapXFields wrapper class

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

	CLSID const& GetClsid()
	{
		static CLSID clsid =
		{ 0x9d6ed186, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } };

		return clsid;
	}

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

// Attributes
public:
	LPENUMVARIANT GetEnumerator();

	long GetCount();

// Operations
public:
	CMapXField Add(const VARIANT& SourceField, const VARIANT& Name, const VARIANT& AggregationFunction, const VARIANT& Type);
	CMapXField Add(LPCTSTR SourceField, LPCTSTR Name="", short AggregationFunction=miAggregationAuto)
		{ return Add(COleVariant(SourceField), COleVariant(Name), COleVariant(AggregationFunction), COptionalVariant()); }
	CMapXField Add(long SourceField, LPCTSTR Name="", short AggregationFunction=miAggregationAuto)
		{ return Add(COleVariant(SourceField), COleVariant(Name), COleVariant(AggregationFunction), COptionalVariant()); }
	CMapXField Item(const VARIANT& Index);
	CMapXField Item(long Index) { return Item(COleVariant(Index)); }
	CMapXField 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();
	CMapXField AddStringField(const VARIANT& Name, const VARIANT& Width);
	CMapXField AddStringField(LPCTSTR Name, long Width)
	{
		return AddStringField(COleVariant(Name), COleVariant(Width));
	}
	CMapXField AddLogicalField(const VARIANT& Name);
	CMapXField AddLogicalField(LPCTSTR Name)
	{
		return AddLogicalField(COleVariant(Name));
	}
	CMapXField AddIntegerField(const VARIANT& Name);
	CMapXField AddIntegerField(LPCTSTR Name)
	{
		return AddIntegerField(COleVariant(Name));
	}
	CMapXField AddSmallIntField(const VARIANT& Name);
	CMapXField AddSmallIntField(LPCTSTR Name)
	{
		return AddSmallIntField(COleVariant(Name));
	}
	CMapXField AddNumericField(const VARIANT& Name, const VARIANT& Precision, const VARIANT& Decimals);
	CMapXField AddNumericField(LPCTSTR Name, long Precision, long Decimals)
	{
		return AddNumericField(COleVariant(Name), COleVariant(Precision), COleVariant(Decimals));
	}
	CMapXField AddFloatField(const VARIANT& Name);
	CMapXField AddFloatField(LPCTSTR Name)
	{
		return AddFloatField(COleVariant(Name));
	}
	CMapXField AddDateField(const VARIANT& Name);
	CMapXField AddDateField(LPCTSTR Name)
	{
		return AddDateField(COleVariant(Name));
	}
};

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

// Attributes
public:
	CString GetName();
	void SetName(LPCTSTR);
	CY GetSize();
	void SetSize(const CY&);
	BOOL GetBold();
	void SetBold(BOOL);
	BOOL GetItalic();
	void SetItalic(BOOL);
	BOOL GetUnderline();
	void SetUnderline(BOOL);
	BOOL GetStrikethrough();
	void SetStrikethrough(BOOL);
	short GetWeight();
	void SetWeight(short);
	short GetCharset();
	void SetCharset(short);

// Operations
public:
};

/////////////////////////////////////////////////////////////////////////////
// CMapXStyle wrapper class

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

	CLSID const& GetClsid()
	{
		// {BB5C2B31-F30E-11d0-9DB6-00AA00A478BC}
		static CLSID clsid =
		{ 0x9d6ed192, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } };

		return clsid;
	}

// Attributes
public:
	short GetSymbolCharacter();
	void SetSymbolCharacter(short);
	unsigned long GetLineColor();
	void SetLineColor(unsigned long);
	short GetLineStyle();
	void SetLineStyle(short);
	short GetLineWidth();
	void SetLineWidth(short);
	unsigned long GetRegionColor();
	void SetRegionColor(unsigned long);
	short GetRegionPattern();
	void SetRegionPattern(short);
	BOOL GetRegionTransparent();
	void SetRegionTransparent(BOOL);
	unsigned long GetRegionBackColor();
	void SetRegionBackColor(unsigned long);
	short GetRegionBorderStyle();
	void SetRegionBorderStyle(short);
	unsigned long GetRegionBorderColor();
	void SetRegionBorderColor(unsigned long);
	short GetRegionBorderWidth();
	void SetRegionBorderWidth(short);
	COleFont GetTextFont();
	COleFont GetSymbolFont();
	unsigned long GetTextFontColor();
	void SetTextFontColor(unsigned long);
	unsigned long GetTextFontBackColor();
	void SetTextFontBackColor(unsigned long);
	unsigned long GetSymbolFontColor();
	void SetSymbolFontColor(unsigned long);
	unsigned long GetSymbolFontBackColor();
	void SetSymbolFontBackColor(unsigned long);
	BOOL GetSymbolFontOpaque();
	void SetSymbolFontOpaque(BOOL);
	BOOL GetTextFontOpaque();
	void SetTextFontOpaque(BOOL);
	BOOL GetSymbolFontHalo();
	void SetSymbolFontHalo(BOOL);
	BOOL GetSymbolFontShadow();
	void SetSymbolFontShadow(BOOL);
	BOOL GetTextFontHalo();
	void SetTextFontHalo(BOOL);
	BOOL GetTextFontShadow();
	void SetTextFontShadow(BOOL);
	BOOL GetTextFontAllCaps();
	void SetTextFontAllCaps(BOOL);
	BOOL GetTextFontDblSpace();
	void SetTextFontDblSpace(BOOL);
	BOOL GetSymbolBitmapTransparent();
	void SetSymbolBitmapTransparent(BOOL bNewValue);
	BOOL GetSymbolBitmapOverrideColor();
	void SetSymbolBitmapOverrideColor(BOOL bNewValue);
	unsigned long GetSymbolBitmapColor();
	void SetSymbolBitmapColor(unsigned long nNewValue);
	CString GetSymbolBitmapName();
	void SetSymbolBitmapName(LPCTSTR lpszNewValue);
	short GetSymbolType();
	void SetSymbolType(short nNewValue);
	long GetSymbolBitmapSize();
	void SetSymbolBitmapSize(long nNewValue);
	BOOL GetSupportsBitmapSymbols();
	short GetSymbolFontRotation();
	void SetSymbolFontRotation(short nNewValue);
	long GetLineStyleCount();
	BOOL GetLineInterleaved();
	void SetLineInterleaved(BOOL bNewValue);
	long GetLineWidthUnit();
	void SetLineWidthUnit(long nNewValue);
	long GetRegionBorderWidthUnit();
	void SetRegionBorderWidthUnit(long nNewValue);
	BOOL GetLineSupportsInterleave();
	short GetTextFontRotation();
	void SetTextFontRotation(short propVal);
	unsigned long GetSymbolVectorColor();
	void SetSymbolVectorColor(unsigned long);
	short GetSymbolVectorSize();
	void SetSymbolVectorSize(short);
	short GetMinVectorSymbolCharacter();
	short GetMaxVectorSymbolCharacter();

// Operations
public:
	BOOL PickRegion();
	BOOL PickLine();
	BOOL PickText();
	BOOL PickSymbol();
	void DrawTextSample(long hDC, LPDISPATCH Rectangle, LPCTSTR SampleText);
	void DrawSymbolSample(long hDC, LPDISPATCH Rectangle);
	void DrawRegionSample(long hDC, LPDISPATCH Rectangle);
	void DrawLineSample(long hDC, LPDISPATCH Rectangle);
	CMapXStyle Clone();
	void ExportSymbolSample(LPCTSTR Destination, short Format, double Width, double Height, const VARIANT& BackgroundColor);
	void ExportRegionSample(LPCTSTR Destination, short Format, double Width, double Height, const VARIANT& BackgroundColor);
	void ExportLineSample(LPCTSTR Destination, short Format, double Width, double Height, const VARIANT& BackgroundColor);
	void ExportTextSample(LPCTSTR Destination, short Format, double Width, double Height, LPCTSTR SampleText, const VARIANT& BackgroundColor);
};
/////////////////////////////////////////////////////////////////////////////
// CMapXIndividualValueCategory wrapper class

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

// Attributes
public:
	CMapXStyle GetStyle();
	void SetStyle(LPDISPATCH);
	long GetNumItems();
	CString GetValue();
	void SetValue(LPCTSTR);

// Operations
public:
};
/////////////////////////////////////////////////////////////////////////////
// CMapXMultivarCategory wrapper class

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

// Attributes
public:
	CMapXStyle GetStyle();
	void SetStyle(LPDISPATCH);

// Operations
public:
};

/////////////////////////////////////////////////////////////////////////////
// CMapXText wrapper class (Same as CMapXGraphic)
// Used for both Text and Symbol annotations
// NOTE: ***OBSOLETE***: Do not use this class use CMapXGraphic instead
class CMapXText : public COleDispatchDriver
{
public:
	CMapXText() {}		// Calls COleDispatchDriver default constructor
	CMapXText(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
	CMapXText(const CMapXText& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}

// Attributes
public:
	CString GetCaption();
	void SetCaption(LPCTSTR);
	double GetX();
	void SetX(double);
	double GetY();
	void SetY(double);
	short GetPosition();
	void SetPosition(short);
	CMapXStyle GetStyle();
	void SetStyle(LPDISPATCH);

// Operations
public:
};

/////////////////////////////////////////////////////////////////////////////
// CMapXGraphic wrapper class (Same as CMapXText)
// Used for both Text and Symbol annotations

class CMapXGraphic : public COleDispatchDriver
{
public:
	CMapXGraphic(