mapx.h

mapx嵌入式插件

	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();
	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 SelectFlag, short SearchResultFlags = miSearchResultAll);
	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) {}

	const CLSID& GetClsid() const
	{
		static bool bInitialized = false;
		static CLSID clsid;
		if(!bInitialized)
		{
			clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Fields.") MAPX_VERSION);
			bInitialized = true;
		}
		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=_T(""), short AggregationFunction=miAggregationAuto)
		{ return Add(COleVariant(SourceField), COleVariant(Name), COleVariant(AggregationFunction), COptionalVariant()); }
	CMapXField Add(long SourceField, LPCTSTR Name=_T(""), 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, const VARIANT& Indexed);
	CMapXField AddStringField(const VARIANT& Name, const VARIANT& Width)
	{
		return AddStringField(Name, Width, COptionalVariant());
	}
	CMapXField AddStringField(LPCTSTR Name, long Width, BOOL Indexed = FALSE)
	{
		short sIndexed = (short) Indexed;
		return AddStringField(COleVariant(Name), COleVariant(Width), COleVariant(sIndexed));
	}
	CMapXField AddLogicalField(const VARIANT& Name, const VARIANT& Indexed);
	CMapXField AddLogicalField(const VARIANT& Name)
	{
		return AddLogicalField(Name, COptionalVariant());
	}
	CMapXField AddLogicalField(LPCTSTR Name, BOOL Indexed = FALSE)
	{
		short sIndexed = (short) Indexed;
		return AddLogicalField(COleVariant(Name), COleVariant(sIndexed));
	}
	CMapXField AddIntegerField(const VARIANT& Name, const VARIANT& Indexed);
	CMapXField AddIntegerField(const VARIANT& Name)
	{
		return AddIntegerField(Name, COptionalVariant());
	}
	CMapXField AddIntegerField(LPCTSTR Name, BOOL Indexed = FALSE)
	{
		short sIndexed = (short) Indexed;
		return AddIntegerField(COleVariant(Name), COleVariant(sIndexed));
	}
	CMapXField AddSmallIntField(const VARIANT& Name, const VARIANT& Indexed);
	CMapXField AddSmallIntField(const VARIANT& Name)
	{
		return AddSmallIntField(Name, COptionalVariant());
	}
	CMapXField AddSmallIntField(LPCTSTR Name, BOOL Indexed = FALSE)
	{
		short sIndexed = (short) Indexed;
		return AddSmallIntField(COleVariant(Name), COleVariant(sIndexed));
	}
	CMapXField AddNumericField(const VARIANT& Name, const VARIANT& Precision, const VARIANT& Decimals, const VARIANT& Indexed);
	CMapXField AddNumericField(const VARIANT& Name, const VARIANT& Precision, const VARIANT& Decimals)
	{
		return AddNumericField(Name, Precision, Decimals, COptionalVariant());
	}
	CMapXField AddNumericField(LPCTSTR Name, long Precision, long Decimals, BOOL Indexed = FALSE)
	{
		short sIndexed = (short) Indexed;
		return AddNumericField(COleVariant(Name), COleVariant(Precision), COleVariant(Decimals), COleVariant(sIndexed));
	}
	CMapXField AddFloatField(const VARIANT& Name, const VARIANT& Indexed);
	CMapXField AddFloatField(const VARIANT& Name)
	{
		return AddFloatField(Name, COptionalVariant());
	}
	CMapXField AddFloatField(LPCTSTR Name, BOOL Indexed = FALSE)
	{
		short sIndexed = (short) Indexed;
		return AddFloatField(COleVariant(Name), COleVariant(sIndexed));
	}
	CMapXField AddDateField(const VARIANT& Name, const VARIANT& Indexed);
	CMapXField AddDateField(const VARIANT& Name)
	{
		return AddDateField(Name, COptionalVariant());
	}
	CMapXField AddDateField(LPCTSTR Name, BOOL Indexed = FALSE)
	{
		short sIndexed = (short) Indexed;
		return AddDateField(COleVariant(Name), COleVariant(sIndexed));
	}
};

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) {}

	const CLSID& GetClsid() const
	{
		static bool bInitialized = false;
		static CLSID clsid;
		if(!bInitialized)
		{
			clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Style.") MAPX_VERSION);
			bInitialized = true;
		}
		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 GetSymbolFontRotat