www.pudn.com > MapXpro006.rar > Mapx.h

#ifndef __MAPX_H__ 
#define __MAPX_H__ 
 
#pragma warning( disable: 4100) 
 
// event dispids 
#define MAPX_DISPID_SELECTION_CHANGED 0x1 
#define MAPX_DISPID_RESOLVEDATABIND 0x2 
#define MAPX_DISPID_TOOLUSED 0x3 
#define MAPX_DISPID_REQUESTDATA 0x4 
#define MAPX_DISPID_DATAMISMATCH 0x5 
#define MAPX_DISPID_MAPVIEWCHANGED 0x6 
#define MAPX_DISPID_ANNOTATIONADDED 0x7 
#define MAPX_DISPID_ANNOTATIONCHANGED 0x8 
#define MAPX_DISPID_THEMEMODIFYREQUESTED 0x9 
#define MAPX_DISPID_DRAWUSERLAYER 0x0a 
#define MAPX_DISPID_POLYTOOLUSED 0x0b 
#define MAPX_DISPID_MOUSEWHEEL 0x0c 
#define MAPX_DISPID_MAPINITIALIZED 0x0d 
#define MAPX_DISPID_RESOLVEDATABINDEX 0xe 
#define MAPX_DISPID_MAPDRAW 0xf 
 
// dispatch id definitions for ole stock events are 
// defined in  
// they are included here for reference 
//#define DISPID_CLICK                    (-600) 
//#define DISPID_DBLCLICK                 (-601) 
//#define DISPID_KEYDOWN                  (-602) 
//#define DISPID_KEYPRESS                 (-603) 
//#define DISPID_KEYUP                    (-604) 
//#define DISPID_MOUSEDOWN                (-605) 
//#define DISPID_MOUSEMOVE                (-606) 
//#define DISPID_MOUSEUP                  (-607) 
//#define DISPID_ERROREVENT               (-608) 
 
 
 
// enum definitions to match typelib 
 
enum ToolConstants 
{ 
	miArrowTool = 1000, 
	miPanTool = 1001, 
	miCenterTool = 1002, 
	miZoomInTool = 1003, 
	miZoomOutTool = 1004, 
	miSymbolTool = 1005, 
	miTextTool = 1006, 
	miSelectTool = 1007, 
	miRadiusSelectTool = 1008, 
	miRectSelectTool = 1009, 
	miPolygonSelectTool = 1010, 
	miLabelTool = 1011, 
	miAddLineTool = 1012, 
	miAddPolylineTool = 1013, 
	miAddRegionTool = 1014, 
	miAddPointTool = 1015 
}; 
 
/* Synchronize this with mimoapp.odl! */ 
enum CursorConstants 
{ 
	miDefaultCursor = 0, 
	miArrowCursor = 1, 
	miCrossCursor = 2, 
	miIBeamCursor = 3, 
	miIconCursor = 4, 
	miSizeCursor = 5, 
	miSizeNESWCursor = 6, 
	miSizeNSCursor = 7, 
	miSizeNWSECursor = 8, 
	miSizeEWCursor = 9, 
	miUpArrowCursor = 10, 
	miHourglassCursor = 11, 
	miNoDropCursor = 12, 
	miArrowHourglassCursor = 13, 
	miArrowQuestionCursor = 14, 
	miSizeAllCursor = 15, 
	miArrowToolCursor = 16, 
	miPanCursor = 17, 
	miCenterCursor = 18, 
	miZoomInCursor = 19, 
	miZoomOutCursor = 20, 
	miSymbolCursor = 21, 
	miTextCursor = 22, 
	miSelectCursor = 23, 
	miRadiusSelectCursor = 24, 
	miRectSelectCursor = 25, 
	miRegionSelectCursor = 26, 
	miInfoCursor = 27, 
	miSelectPlusCursor = 28, 
	miSelectRadiusPlusCursor = 29, 
	miSelectRectPlusCursor = 30, 
	miSelectRegionPlusCursor = 31, 
	miSelectMinusCursor = 32, 
	miSelectRadiusMinusCursor = 33, 
	miSelectRectMinusCursor = 34, 
	miSelectRegionMinusCursor = 35, 
	miLabelCursor = 36, 
	miDrilldownExpandCursor = 37, 
	miDrilldownContractCursor = 38, 
	miInfoCursorOld = 39, 
	miCustomCursor = 40 
}; 
 
 
enum MapUnitConstants 
{ 
	miUnitMile = 0, 
	miUnitKilometer = 1, 
	miUnitInch = 2, 
	miUnitFoot = 3, 
	miUnitYard = 4, 
	miUnitMillimeter = 5, 
	miUnitCentimeter = 6, 
	miUnitMeter = 7, 
	miUnitSurveyFoot = 8, 
	miUnitNauticalMile = 9, 
	miUnitTwip = 10, 
	miUnitPoint = 11, 
	miUnitPica = 12, 
	miUnitDegree = 13, 
	miUnitLink = 30, 
	miUnitChain = 31, 
	miUnitRod = 32 
}; 
 
enum PaperUnitConstants 
{ 
	miPaperUnitMile = 0, 
	miPaperUnitKilometer = 1, 
	miPaperUnitInch = 2, 
	miPaperUnitFoot = 3, 
	miPaperUnitYard = 4, 
	miPaperUnitMillimeter = 5, 
	miPaperUnitCentimeter = 6, 
	miPaperUnitMeter = 7, 
	miPaperUnitSurveyFoot = 8, 
	miPaperUnitNauticalMile = 9, 
	miPaperUnitTwip = 10, 
	miPaperUnitPoint = 11, 
	miPaperUnitPica = 12, 
	miPaperUnitDegree = 13, 
	miPaperUnitLink = 30, 
	miPaperUnitChain = 31, 
	miPaperUnitRod = 32 
}; 
 
enum SelectionTypeConstants 
{ 
	miSelectionNew = 0, 
	miSelectionAppend = 1, 
	miSelectionRemove = 2 
}; 
 
enum ConversionConstants 
{ 
	miMapToScreen = 0, 
	miScreenToMap = 1 
}; 
 
enum DotSizeConstants 
{ 
	miDotSizeSmall = 0, 
	miDotSizeLarge = 1 
}; 
 
enum DistribMethodConstants 
{ 
	miCustomRanges = 0, 
	miEqualCountPerRange = 1, 
	miEqualRangeSize = 2, 
	miNaturalBreak = 3, 
	miStandardDeviation = 4 
}; 
 
enum PenStyleConstants 
{ 
	miPenNone = 0, 
	miPenSolid = 1 
}; 
 
enum FieldTypeConstants 
{ 
	miTypeString = 0, 
	miTypeNumeric = 1, 
	miTypeDate = 2, 
	miTypeInteger = 3, 
	miTypeSmallInt = 4, 
	miTypeFloat = 5, 
	miTypeLogical = 6 
}; 
 
enum AggregationFunctionConstants 
{ 
	miAggregationSum = 0, 
	miAggregationAverage = 1, 
	miAggregationCount = 2, 
	miAggregationIndividual = 4, 
	miAggregationAuto = 5 
}; 
 
enum FillPatternConstants 
{ 
	miPatternNoFill = 0, 
	miPatternHollow = 1, 
	miPatternSolid = 2, 
	miPatternHorizontal = 3, 
	miPatternVertical = 4, 
	miPatternFDiag = 5, 
	miPatternFilBDiag = 6, 
	miPatternCross = 7, 
	miPatternDiagCross = 8 
}; 
 
enum ThemeTypeConstants 
{ 
	miThemeRanged = 0, 
	miThemeBarChart = 1, 
	miThemePieChart = 2, 
	miThemeGradSymbol = 3, 
	miThemeDotDensity = 4, 
	miThemeIndividualValue = 5, 
	miThemeAuto = 6, 
	miThemeNone = 9, 
}; 
 
enum AnnotationTypeConstants 
{ 
	miSymbolAnnotation = 1, 
	miTextAnnotation = 6, 
}; 
 
enum ToolTypeConstants 
{ 
	miToolTypePoint = 0, 
	miToolTypeLine = 1, 
	miToolTypeCircle = 2, 
	miToolTypeMarquee = 3, 
	miToolTypePoly = 4, 
	miToolTypePolygon = 5 
}; 
 
enum PolyToolFlagConstants 
{ 
	miPolyToolBegin = 0, 
	miPolyToolEnd = 1, 
	miPolyToolEndEscaped = 2, 
	miPolyToolInProgress = 3 
}; 
 
enum DatasetTypeConstants 
{ 
	miDataSetDAO = 1, 
	miDataSetODBC = 2, 
	miDataSetUnbound = 3, 
	miDataSetGlobalHandle = 4, 
	miDataSetOLEData = 5, 
	miDataSetLayer = 6, 
	miDataSetNotesView = 7, 
	miDataSetNotesQuery = 8, 
	miDataSetSafeArray = 9, 
	miDataSetOEO = 10, 
	miDataSetDelphi = 1010, 
	miDataSetDelphi4 = 1011, 
	miDataSetDelphi5 = 1012, 
	miDataSetADO = 12, 
	miDataSetRDO = 13 
}; 
 
enum AnnotationChangedTypeConstants 
{ 
	miAddAnnotation = 0, 
	miDeleteAnnotation = 1, 
	miSelectAnnotation = 2, 
	miEditAnnotation = 3 
}; 
 
enum ResolveDataBindConstants 
{ 
	miChooseField = 0, 
	miChooseLayer = 1, 
	miChooseGeoSet = 2 
}; 
 
enum SpreadByConstants 
{ 
	miSpreadByNone = 0, 
	miSpreadByColor = 1, 
	miSpreadBySize = 2 
}; 
 
enum BindLayerTypeConstants 
{ 
	miBindLayerTypeNormal = 0, 
	miBindLayerTypeXY = 1, 
	miBindLayerTypePointRef = 2 
}; 
 
enum ExportFormatConstants 
{ 
	miFormatWMF = 0, 
	miFormatBMP = 1, 
	miFormatGIF = 2, 
	miFormatJPEG = 3, 
	miFormatTIF = 4, 
	miFormatPNG = 5, 
	miFormatPSD = 6 
}; 
 
enum FeatureTypeConstants 
{ 
	miFeatureTypeRegion = 0, 
	miFeatureTypeLine = 1, 
	miFeatureTypeSymbol = 2, 
	miFeatureTypeMixed = 3, 
	miFeatureTypeUnknown = 4, 
	miFeatureTypeText = 5, 
	miFeatureTypeNull = 6 
}; 
 
enum LineTypeConstants 
{ 
	miLineTypeNone = 0, 
	miLineTypeSimple = 1, 
	miLineTypeArrow = 2 
}; 
 
enum PositionConstants 
{ 
	miPositionCC = 0, 
	miPositionTL = 1, 
	miPositionTC = 2, 
	miPositionTR = 3, 
	miPositionCL = 4, 
	miPositionCR = 5, 
	miPositionBL = 6, 
	miPositionBC = 7, 
	miPositionBR = 8 
}; 
 
enum SearchTypeConstants 
{ 
	miSearchTypeCentroidWithin = 0, 
	miSearchTypePartiallyWithin = 1, 
	miSearchTypeEntirelyWithin = 2 
}; 
 
enum LayerTypeConstants 
{ 
	miLayerTypeNormal = 0, 
	miLayerTypeRaster = 2, 
	miLayerTypeSeamless = 4, 
	miLayerTypeUnknown = 5, 
	miLayerTypeUserDraw = 6, 
  miLayerTypeDrilldown = 7, 
}; 
 
enum AreaUnitConstants 
{ 
	miUnitSquareMile = 14, 
	miUnitSquareKilometer = 15, 
	miUnitSquareInch = 16, 
	miUnitSquareFoot = 17, 
	miUnitSquareYard = 18, 
	miUnitSquareMillimeter = 19, 
	miUnitSquareCentimeter = 20, 
	miUnitSquareMeter = 21, 
	miUnitSquareSurveyFoot = 22, 
	miUnitSquareNauticalMile = 23, 
	miUnitSquareTwip = 24, 
	miUnitSquarePoint = 25, 
	miUnitSquarePica = 26, 
	miUnitSquareDegree = 27, 
	miUnitAcre = 28, 
	miUnitHectare = 29, 
	miUnitSquareLink = 33, 
	miUnitSquareChain = 34, 
	miUnitSquareRod = 35, 
	miUnitPerch = 36, 
	miUnitRood = 37 
}; 
 
enum ColorConstants 
{ 
	miColorBlack = 0, 
	miColorRed = 255, 
	miColorGreen = 65280, 
	miColorBlue = 16711680, 
	miColorMagenta = 16711935, 
	miColorCyan = 16776960, 
	miColorWhite = 16777215, 
	miColorLightGray = 12632256, 
	miColorDarkGray = 4210752, 
	miColorGray = 8421504, 
	miColorPaleYellow = 13697023, 
	miColorLightYellow = 8454143, 
	miColorYellow = 65535, 
	miColorLimeGreen = 12639424, 
	miColorTeal = 8421440, 
	miColorDarkGreen = 16384, 
	miColorMaroon = 128, 
	miColorPurple = 8388736, 
	miColorOrange = 33023, 
	miColorKhaki = 7051175, 
	miColorOlive = 32896, 
	miColorBrown = 4210816, 
	miColorNavy = 8404992, 
	miColorScrollBars = 0x80000000, 
	miColorDesktop = 0x80000001, 
	miColorActiveTitleBar = 0x80000002, 
	miColorInactiveTitleBar = 0x80000003, 
	miColorMenuBar = 0x80000004, 
	miColorWindowBackground = 0x80000005, 
	miColorWindowFrame = 0x80000006, 
	miColorMenuText = 0x80000007, 
	miColorWindowText = 0x80000008, 
	miColorTitleBarText = 0x80000009, 
	miColorActiveBorder = 0x8000000A, 
	miColorInactiveBorder = 0x8000000B, 
	miColorApplicationWorkspace = 0x8000000C, 
	miColorHighlight = 0x8000000D, 
	miColorHighlightText = 0x8000000E, 
	miColorButtonFace = 0x8000000F, 
	miColorButtonShadow = 0x80000010, 
	miColorGrayText = 0x80000011, 
	miColorButtonText = 0x80000012, 
	miColorInactiveCaptionText = 0x80000013, 
	miColor3DHighlight = 0x80000014, 
	miColor3DDarkShadow = 0x80000015, 
	miColor3DLight = 0x80000016, 
	miColorInfoText = 0x80000017, 
	miColorInfoBackground = 0x80000018, 
}; 
 
enum CircleTypeConstants 
{ 
	miCircleTypeScreen= 0, 
	miCircleTypeMap = 1, 
}; 
 
enum CoordSysTypeConstants 
{ 
	miNonEarth = 0, 
	miLongLat = 1, 
	miCylindricalEqualArea = 2, 
	miLambertConformalConic = 3, 
	miLambertAzimuthalEqualArea = 4, 
	miAzimuthalEquidistant = 5, 
	miEquidistantConic = 6, 
	miHotineObliqueMercator = 7, 
	miTransverseMercator = 8, 
	miAlbersEqualAreaConic = 9, 
	miMercator = 10, 
	miMillerCylindrical = 11, 
	miRobinson = 12, 
	miMollweide = 13, 
	miEckertIV = 14, 
	miEckertVI = 15, 
	miSinusoidal = 16, 
	miGall = 17, 
	miNewZealandMapGrid = 18, 
	miLambertConformalConicBelgium = 19, 
	miStereographic = 20, 
	miTransverseMercatorDenmarkS34J = 21, 
	miTransverseMercatorDenmarkS34S = 22, 
	miTransverseMercatorDenmarkS45B = 23, 
	miTransverseMercatorFinland = 24, 
	miSwissObliqueMercator = 25 
}; 
 
enum SymbolTypeConstants 
{ 
	miSymbolTypeTrueTypeFont = 0, 
	miSymbolTypeBitmap = 1, 
	miSymbolTypeVector = 2 
}; 
 
enum IntersectionTestConstants 
{ 
	miIntersectCentroidWithinFeature = 0, 
	miIntersectFeature = 1, 
	miIntersectEntirelyWithinFeature = 2 
}; 
 
enum IntersectionPointConstants 
{ 
	miIntersectCrossings = 9, 
	miIntersectCommon = 10, 
	miIntersectAll = 11 
}; 
 
enum MousewheelSupportConstants 
{ 
	miNoMousewheelSupport = 1, 
	miMousewheelNoAutoScroll = 2, 
	miFullMousewheelSupport = 3	 
}; 
 
enum StyleUnitConstants 
{ 
	miStyleUnitPixel = 0, 
	miStyleUnitTenthsOfPoint = 1 
}; 
 
enum ServerLayerOptions // bit mask for long, must be power of 2 
{ 
	miLayerCacheOn = 0,			// default = Cache on 
	miLayerMBRSearchOn = 0,	// default = Search on 
	miLayerCacheOff = 1, 
	miMBRSearchOff  = 2 
}; 
 
enum GraduationConstants 
{ 
	miGraduateBySquareRoot = 0, 
	miGraduateByConstant = 1, 
	miGraduateByLogarithm = 2 
}; 
 
enum ColorSpreadingMethodConstants 
{ 
	miColorMethodRGB = 0, 
	miColorMethodHSV = 1 
}; 
 
enum ApplyAttributeConstants 
{ 
	miApplyAttributeAll = 0, 
	miApplyAttributeColor = 1, 
	miApplyAttributeSize = 2 
}; 
 
enum LayerBeginAccessConstants 
{ 
	miAccessRead= 0, 
	miAccessReadWrite = 1, 
}; 
 
enum LayerEndAccessConstants 
{ 
	miAccessEnd= 0, 
}; 
 
enum LayerInfoTypeConstants 
{ 
	miLayerInfoTypeTab = 0, 
	miLayerInfoTypeUserDraw = 1, 
	miLayerInfoTypeRaster = 2, 
	miLayerInfoTypeShape = 3, 
	miLayerInfoTypeServer = 4, 
	miLayerInfoTypeGeodictUserName = 5, 
	miLayerInfoTypeTemp = 6, 
	miLayerInfoTypeNewTable = 7 
}; 
 
enum MapDrawConstants 
{ 
	miDrawBegin = 1, 
	miDrawEnd = 2 
}; 
 
enum ToolFlagConstants 
{ 
	miToolBegin = 0, 
	miToolEnd = 1, 
	miToolEndEscaped = 2, 
	miToolInProgress = 3, 
	miToolCompleted = 4 
}; 
 
enum FeatureEditModeConstants 
{ 
	miEditModeFeature = 1, 
	miEditModeNode = 2, 
	miMoveDuplicateNodes = 4, 
	miDeleteDuplicateNodes = 8, 
	miEditModeAddNode = 64 
}; 
 
// forward delcarations 
class CMapXAnnotations; 
class CMapXLayers; 
class CMapXDatasets; 
class CMapXStyle; 
class CMapXTitle; 
class CMapXAnnotation; 
class CMapXGraphic; 
class CMapXLayer; 
class CMapXSelection; 
class CMapXFeatures; 
class CMapXFeature; 
class CMapXDataset; 
class CMapXFields; 
class CMapXField; 
class CMapXThemes; 
class CMapXTheme; 
class CMapXLegend; 
class CMapXLegendTexts; 
class CMapXLegendText; 
class CMapXRangeCategories; 
class CMapXIndividualValueCategories; 
class CMapXMultivarCategories; 
class CMapXThemeProperties; 
class CMapXLabelProperties; 
class CMapXIndividualValueCategory; 
class CMapXRangeCategory; 
class CMapXMultivarCategory; 
class CMapXSourceRows; 
class CMapXSourceRow; 
class CMapXLayerFind; 
class CMapXFindFeature; 
class CMapXFindResult; 
class CMapXFindMatches; 
class CMapXFindMatch; 
class CMapXRectangle; 
class CMapXGeosets; 
class CMapXGeoset; 
class CMapXParts; 
class CMapXPoints; 
class CMapXPoint; 
class CMapXCoordSys; 
class CMapXBitmapSymbols; 
class CMapXBitmapSymbol; 
class CMapXFeatureFactory; 
class CMapXResolveObjects; 
class CMapXResolveObject; 
class CMapXRowValues; 
class CMapXRowValue; 
class CMapXLayerInfo; 
class COptionalVariant; 
 
 
// simple class to pass to methods that take 
// a variant that we want to mark as optional (not supplied by the method call) 
class COptionalVariant: public COleVariant 
{ 
public: 
	COptionalVariant() { vt = VT_ERROR; scode = DISP_E_PARAMNOTFOUND; } 
}; 
 
// another helper class to handle dispatch variants 
class COleVariantDispatch: public COleVariant 
{ 
public: 
	COleVariantDispatch(LPDISPATCH pdisp) 
	{ 
    vt = VT_DISPATCH; 
    pdispVal = pdisp; 
		pdispVal->AddRef(); 
	} 
}; 
 
 
// to derive CMapX from COleDispatchDriver instead of CWnd, 
// comment out the next line 
#define CWND_MAPX 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapX wrapper class 
#ifdef CWND_MAPX 
 
//---------------------------- 
class CMapX : public CWnd 
{ 
protected: 
	DECLARE_DYNCREATE(CMapX) 
public: 
	CLSID const& GetClsid() 
	{ 
	static CLSID const clsid = 
		{ 0x9d6ed188, 0x5910, 0x11d2,  { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
		return clsid; 
	} 
	virtual BOOL Create(LPCTSTR lpszClassName, 
		LPCTSTR lpszWindowName, DWORD dwStyle, 
		const RECT& rect, 
		CWnd* pParentWnd, UINT nID, 
		CCreateContext* pContext = NULL) 
	{ return CreateControl(GetClsid(), lpszWindowName, dwStyle, rect, pParentWnd, nID); } 
 
	BOOL Create(LPCTSTR lpszWindowName, DWORD dwStyle, 
		const RECT& rect, CWnd* pParentWnd, UINT nID, 
		CFile* pPersist = NULL, BOOL bStorage = FALSE, 
		BSTR bstrLicKey = NULL) 
	{ return CreateControl(GetClsid(), lpszWindowName, dwStyle, rect, pParentWnd, nID, 
		pPersist, bStorage, bstrLicKey); } 
 
#else 
 
class CMapX : public COleDispatchDriver 
{ 
public: 
	CLSID const& GetClsid() 
	{ 
	static CLSID const clsid = 
		{ 0x9d6ed188, 0x5910, 0x11d2,  { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
		return clsid; 
	} 
#endif //of #ifdef CWND_MAPX 
 
	// default bAddRef is false because you don't need to addref 
	// when passing result to Feature.Attach(); 
	LPDISPATCH GetDispatch(BOOL bAddRef=FALSE); 
 
// Attributes 
public: 
	CString GetVersion(); 
	OLE_HANDLE GetHWnd(); 
	CMapXAnnotations GetAnnotations(); 
	CMapXLayers GetLayers(); 
	BOOL GetAutoRedraw(); 
	void SetAutoRedraw(BOOL); 
	double GetZoom(); 
	void SetZoom(double); 
	double GetCenterX(); 
	void SetCenterX(double); 
	double GetCenterY(); 
	void SetCenterY(double); 
	CString GetGeoSet(); 
	void SetGeoSet(LPCTSTR); 
	double GetGeoSetWidth(); 
	double GetMapPaperHeight(); 
	double GetMapPaperWidth(); 
	short GetMaxSearchTime(); 
	void SetMaxSearchTime(short); 
	long GetPaperUnit(); 
	void SetPaperUnit(long); 
	BOOL GetPreferCompactLegends(); 
	void SetPreferCompactLegends(BOOL); 
	CMapXStyle GetDefaultStyle(); 
	void SetDefaultStyle(LPDISPATCH); 
	CString GetGeoDictionary(); 
	// this method currently will not work in 'run' mode. which 
	// is the only mode MFC Control containers support, so don't bother calling it. 
	void SetGeoDictionary(LPCTSTR); 
 
	long GetDataSetTheme(); 
	void SetDataSetTheme(long); 
	long GetCurrentTool(); 
	void SetCurrentTool(long); 
	long GetMousePointer(); 
	void SetMousePointer(long); 
	CMapXDatasets GetDatasets(); 
	CMapXTitle GetTitle(); 
	CString GetTitleText(); 
	void SetTitleText(LPCTSTR); 
	long GetMapUnit(); 
	void SetMapUnit(long); 
	double GetRotation(); 
	void SetRotation(double); 
	CMapXGeosets GetGeosets(); 
	long GetAreaUnit(); 
	void SetAreaUnit(long); 
	CMapXRectangle GetBounds(); 
	void SetBounds(LPDISPATCH); 
	CMapXCoordSys GetDisplayCoordSys(); 
	void SetDisplayCoordSys(LPDISPATCH); 
	CMapXCoordSys GetNumericCoordSys(); 
	void SetNumericCoordSys(LPDISPATCH); 
	BOOL GetExportSelection(); 
	void SetExportSelection(BOOL); 
	CMapXStyle GetSelectionStyle(); 
	void SetSelectionStyle(LPDISPATCH); 
	CMapXFeatureFactory GetFeatureFactory(); 
	long GetDefaultConversionResolution(); 
	void SetDefaultConversionResolution(long); 
	long GetBackColor(); 
	void SetBackColor(long); 
	long GetMousewheelSupport(); 
	void SetMousewheelSupport(long); 
	BOOL GetMatchNumericFields(); 
	void SetMatchNumericFields(BOOL); 
	double GetMapScreenWidth(); 
	double GetMapScreenHeight(); 
	CString GetSearchPath(); 
	void SetSearchPath(LPCTSTR propVal); 
	long GetRedrawInterval(); 
	void SetRedrawInterval(long l); 
	short GetMatchThreshold(); 
	void SetMatchThreshold(short l); 
	BOOL GetWaitCursorEnabled(); 
	void SetWaitCursorEnabled(BOOL b); 
	BOOL GetPanAnimationLayer(); 
	void SetPanAnimationLayer(BOOL b); 
	long GetInfotipPopupDelay(); 
	void SetInfotipPopupDelay(long propVal); 
	CString GetMouseIcon(); 
	void SetMouseIcon(LPCTSTR propVal); 
	BOOL GetInfotipSupport(); 
	void SetInfotipSupport(BOOL b); 
	short GetFeatureEditMode(); 
	void SetFeatureEditMode(short); 
 
// Operations 
public: 
	void ConvertCoord(float* ScreenX, float* ScreenY, double* MapX, double* MapY, short Direction); 
	void ZoomTo(double Zoom, double X, double Y); 
	 
	void CreateCustomTool(short ToolNumber, short Type, const VARIANT& Cursor, const VARIANT& ShiftCursor, const VARIANT& CtrlCursor, const VARIANT& bInfoTips); 
	void CreateCustomTool(short ToolNumber, short Type, short Cursor) 
	{ CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COptionalVariant(), COptionalVariant(), COptionalVariant()); } 
	void CreateCustomTool(short ToolNumber, short Type, LPCTSTR Cursor) 
	{ CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COptionalVariant(), COptionalVariant(), COptionalVariant()); } 
	void CreateCustomTool(short ToolNumber, short Type, short Cursor, bool bInfoTips) 
	{ 
		short sInfoTips = (short) bInfoTips; 
		CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COptionalVariant(), COptionalVariant(), COleVariant(sInfoTips)); 
	} 
	void CreateCustomTool(short ToolNumber, short Type, LPCTSTR Cursor, bool bInfoTips) 
	{ 
		short sInfoTips = (short) bInfoTips; 
		CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COptionalVariant(), COptionalVariant(), COleVariant(sInfoTips)); 
	} 
	void CreateCustomTool(short ToolNumber, short Type, short Cursor, short ShiftCursor, short CtrlCursor) 
	{ CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COleVariant(ShiftCursor), COleVariant(CtrlCursor), COptionalVariant()); } 
	void CreateCustomTool(short ToolNumber, short Type, LPCTSTR Cursor, LPCTSTR ShiftCursor, LPCTSTR CtrlCursor) 
	{ CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COleVariant(ShiftCursor), COleVariant(CtrlCursor), COptionalVariant()); } 
	void CreateCustomTool(short ToolNumber, short Type, short Cursor, short ShiftCursor, short CtrlCursor, bool bInfoTips) 
	{ 
		short sInfoTips = (short) bInfoTips; 
		CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COleVariant(ShiftCursor), COleVariant(CtrlCursor), COleVariant(sInfoTips)); 
	} 
	void CreateCustomTool(short ToolNumber, short Type, LPCTSTR Cursor, LPCTSTR ShiftCursor, LPCTSTR CtrlCursor, bool bInfoTips) 
	{ 
		short sInfoTips = (short) bInfoTips; 
		CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COleVariant(ShiftCursor), COleVariant(CtrlCursor), COleVariant(sInfoTips)); 
	} 
 
	double Distance(double X1, double Y1, double X2, double Y2); 
	void Refresh(); 
	void PrintMap(long hDC, long X, long Y, long W, long H); 
 
	void ExportMap(LPCTSTR Destination, short Format, const VARIANT& Width, const VARIANT& Height); 
	void ExportMap(LPCTSTR Destination, short Format) 
		{	ExportMap(Destination, Format, COptionalVariant(), COptionalVariant()); } 
	void ExportMap(LPCTSTR Destination, short Format, double Width, double Height) 
		{	ExportMap(Destination, Format, COleVariant(Width), COleVariant(Height)); } 
	 
	void PropertyPage(); 
	void ConvertCoordV(VARIANT* ScreenX, VARIANT* ScreenY, VARIANT* MapX, VARIANT* MapY, short Direction); 
	void SetSize(long Width, long Height); 
	BOOL IsPointVisible(double X, double Y); 
	BOOL ClipLine(double* X1, double* Y1, double* X2, double* Y2); 
	BOOL ClipLineV(VARIANT* X1, VARIANT* Y1, VARIANT* X2, VARIANT* Y2); 
	void SaveMapAsGeoset(LPCTSTR Name, LPCTSTR Filespec); 
	void Pan(float ScreenX, float ScreenY); 
	void AboutBox(); 
}; 
 
// EVENT Prototypes 
// For dispatch objects passed to events, the event handler should not change the reference count 
// ie: do not call release on the object because an ocx does not do an addref before passing the 
// object to the event 
/* 
	void Click(); 
	void DblClick(); 
	void Error(short Number, BSTR* Description, long Scode, LPCTSTR Source, LPCTSTR HelpFile, long HelpContext, BOOL* CancelDisplay); 
	void KeyDown(short* KeyCode, short Shift); 
	void KeyPress(short* KeyAscii); 
	void KeyUp(short* KeyCode, short Shift); 
	void MouseMove(short Button, short Shift, float X, float Y); 
	void MouseDown(short Button, short Shift, float X, float Y); 
	void MouseUp(short Button, short Shift, float X, float Y); 
	void SelectionChanged(); 
	void ResolveDataBind(short Flag, short NumMatches, const VARIANT& Matches, short* Choice, BOOL* Cancel); 
	void ToolUsed(short ToolNum, double X1, double Y1, double X2, double Y2, double Distance, BOOL Shift, BOOL Ctrl, BOOL* EnableDefault); 
	void RequestData(LPCTSTR DataSetName, long Row, short Field, VARIANT* Value, BOOL* Done); 
	void DataMismatch(LPCTSTR DataSetName, long Row, BSTR* GeoFieldValue); 
	void MapViewChanged(); 
	void AnnotationAdded(LPDISPATCH Annotation); 
	void AnnotationChanged(short ChangeType, LPDISPATCH Annotation, BOOL* EnableDefault); 
	void ThemeModifyRequested(LPDISPATCH Theme); 
	void DrawUserLayer(LPDISPATCH Layer, long hOutputDC, long hAttributeDC, LPDISPATCH RectFull, LPDISPATCH RectInvalid); 
	void PolyToolUsed(short ToolNum, long Flags, LPDISPATCH Points, BOOL bShift, BOOL bCtrl, BOOL FAR* EnableDefault) 
	void ResolveDataBindEx(short Flag, short NumMatches, const VARIANT& Matches, short* Choice, BOOL* Cancel); 
	void MapDraw(short Flag); 
	void AddFeatureToolUsed(short ToolNum, long Flags, IDispatch* Feature, boolean bShift, boolean bCtrl, boolean* EnableDefault); 
*/ 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXSourceRow wrapper class 
 
class CMapXSourceRow : public COleDispatchDriver 
{ 
public: 
	CMapXSourceRow() {}		// Calls COleDispatchDriver default constructor 
	CMapXSourceRow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXSourceRow(const CMapXSourceRow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	long GetRow(); 
 
// Operations 
public: 
}; 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXSourceRows wrapper class 
 
class CMapXSourceRows : public COleDispatchDriver 
{ 
public: 
	CMapXSourceRows() {}		// Calls COleDispatchDriver default constructor 
	CMapXSourceRows(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXSourceRows(const CMapXSourceRows& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXSourceRow operator[](long Index) { return Item(Index); } 
 
// Attributes 
public: 
	long GetCount(); 
 
// Operations 
public: 
	CMapXSourceRow Item(const VARIANT& Index); 
	CMapXSourceRow Item(long Index) { return Item(COleVariant(Index)); } 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXRowValues wrapper class 
 
class CMapXRowValues : public COleDispatchDriver 
{ 
public: 
	CMapXRowValues() {}		// Calls COleDispatchDriver default constructor 
	CMapXRowValues(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXRowValues(const CMapXRowValues& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
		static CLSID clsid = 
		{ 0x7a5ffdc1, 0xfe6c, 0x11d2, { 0x98, 0xa9, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	long GetCount(); 
	BOOL GetReadOnly(); 
 
// Operations 
public: 
	CMapXRowValue Item(const VARIANT& Index); 
	void Remove(const VARIANT& Index); 
	CMapXRowValue Add(LPDISPATCH RowValue); 
	void RemoveAll(); 
	CMapXRowValues Clone(); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXRowValue wrapper class 
 
class CMapXRowValue : public COleDispatchDriver 
{ 
public: 
	CMapXRowValue() {}		// Calls COleDispatchDriver default constructor 
	CMapXRowValue(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXRowValue(const CMapXRowValue& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
		static CLSID clsid = 
		{ 0x2ef654e1, 0xfe50, 0x11d2, { 0x98, 0xa9, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	BOOL GetReadOnly(); 
	LPDISPATCH GetDataset(); 
	void SetDataset(LPDISPATCH); 
	LPDISPATCH GetField(); 
	void SetField(LPDISPATCH); 
	VARIANT GetValue(); 
	void SetValue(const VARIANT&); 
 
// Operations 
public: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXDataset wrapper class 
 
class CMapXDataset : public COleDispatchDriver 
{ 
public: 
	CMapXDataset() {}		// Calls COleDispatchDriver default constructor 
	CMapXDataset(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXDataset(const CMapXDataset& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CString GetName(); 
	void SetName(LPCTSTR); 
	long GetRowCount(); 
	CMapXFields GetFields(); 
	CMapXThemes GetThemes(); 
	long GetGeoField(); 
	long GetSecondaryGeoField(); 
	CMapXLayer GetLayer(); 
	short GetType(); 
	BOOL GetReadOnly(); 
 
// Operations 
public: 
	void Refresh(); 
	VARIANT GetValue(const VARIANT& Row, const VARIANT& Column); 
	VARIANT GetValue(long Row, long Column) 
	{ return GetValue(COleVariant(Row), COleVariant(Column)); } 
	VARIANT GetValue(long Row, LPCTSTR Column) 
	{ return GetValue(COleVariant(Row), COleVariant(Column)); } 
	 
	CMapXSourceRows GetSourceRows(const VARIANT& Row); 
	CMapXSourceRows GetSourceRows(long Row) 
	{ return GetSourceRows(COleVariant(Row)); } 
 
	CMapXRowValues GetRowValues(const VARIANT& Row); 
	CMapXRowValues GetRowValues(long Row) 
	{ return GetRowValues(COleVariant(Row)); } 
 
	CMapXField AddField(LPCTSTR Name, LPCTSTR Expression); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXDatasets wrapper class 
 
class CMapXDatasets : public COleDispatchDriver 
{ 
public: 
	CMapXDatasets() {}		// Calls COleDispatchDriver default constructor 
	CMapXDatasets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXDatasets(const CMapXDatasets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	long GetCount(); 
	 
	CMapXDataset operator[](long Index) { return Item(Index); } 
	CMapXDataset operator[](LPCTSTR Index) { return Item(Index); } 
 
	BOOL GetBuildSourceRows(); 
	void SetBuildSourceRows(BOOL b); 
 
 
// Operations 
public: 
	CMapXDataset Add(long Type, const VARIANT& SourceData, const VARIANT& Name, const VARIANT& GeoField, const VARIANT& SecondaryGeoField, const VARIANT& BindLayer, const VARIANT& Fields, const VARIANT& Dynamic); 
	CMapXDataset Add(short Type, const VARIANT& SourceData, LPCTSTR Name=NULL, long GeoField=0) 
		{ return Add(Type, SourceData, COleVariant(Name), COleVariant(GeoField), 
								COptionalVariant(), COptionalVariant(), COptionalVariant(), COptionalVariant()); 
		} 
	CMapXDataset Item(const VARIANT& Index); 
	CMapXDataset Item(long Index) { return Item(COleVariant(Index)); } 
	CMapXDataset 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)); } 
	CMapXDataset Restore(LPCTSTR Name, const VARIANT& SourceData); 
	void RemoveAll(); 
 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXLabelProperties wrapper class 
 
class CMapXLabelProperties : public COleDispatchDriver 
{ 
public: 
	CMapXLabelProperties() {}		// Calls COleDispatchDriver default constructor 
	CMapXLabelProperties(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXLabelProperties(const CMapXLabelProperties& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CMapXStyle GetStyle(); 
	void SetStyle(LPDISPATCH); 
	BOOL GetVisible(); 
	void SetVisible(BOOL); 
	BOOL GetLabelZoom(); 
	void SetLabelZoom(BOOL); 
	double GetLabelZoomMin(); 
	void SetLabelZoomMin(double); 
	double GetLabelZoomMax(); 
	void SetLabelZoomMax(double); 
	short GetLineType(); 
	void SetLineType(short); 
	short GetOffset(); 
	void SetOffset(short); 
	BOOL GetParallel(); 
	void SetParallel(BOOL); 
	CMapXDataset GetDataset(); 
	void SetDataset(LPDISPATCH); 
	BOOL GetDuplicate(); 
	void SetDuplicate(BOOL); 
	BOOL GetOverlap(); 
	void SetOverlap(BOOL); 
	short GetLabelMax(); 
	void SetLabelMax(short); 
	CMapXField GetDataField(); 
	void SetDataField(LPDISPATCH); 
	short GetPosition(); 
	void SetPosition(short); 
	BOOL GetPartialSegments(); 
	void SetPartialSegments(BOOL); 
 
// Operations 
public: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXFeature wrapper class 
 
class CMapXFeature : public COleDispatchDriver 
{ 
public: 
	CMapXFeature() {}		// Calls COleDispatchDriver default constructor 
	CMapXFeature(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXFeature(const CMapXFeature& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
		static CLSID clsid = 
		{ 0x9d6ed187, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	long GetFeatureID(); 
	short GetType(); 
	void SetType(short); 
	double GetLength(); 
	double GetCenterX(); 
	double GetCenterY(); 
	CMapXStyle GetStyle(); 
	void SetStyle(LPDISPATCH); 
	CMapXRectangle GetBounds(); 
	CMapXParts GetParts(); 
	double GetArea(); 
	CMapXLayer GetLayer(); 
	CString GetCaption(); 
	void SetCaption(LPCTSTR); 
	CMapXPoint GetPoint(); 
	void SetPoint(LPDISPATCH); 
	CMapXPoint GetLabelPoint(); 
	double GetPerimeter(); 
	BOOL GetSmooth(); 
	void SetSmooth(BOOL); 
	CString GetName(); 
	CString GetKeyValue(); 
	void SetKeyValue(LPCTSTR); 
	CString GetFeatureKey(); 
 
// Operations 
public: 
	void Update(const VARIANT& UpdateFeature, const VARIANT& RowValues); 
	void Update(bool UpdateFeature, LPDISPATCH RowValues) 
	{ Update(COleVariant((short)UpdateFeature), COleVariantDispatch(RowValues)); } 
	void Update(bool UpdateFeature) 
	{ 
		short sUpdateFeature = (short) UpdateFeature; 
 
		Update(COleVariant(sUpdateFeature), COptionalVariant()); 
	} 
	void Update(LPDISPATCH RowValues) 
	{ 
		Update(COptionalVariant(), COleVariantDispatch(RowValues)); 
	} 
	void Update() 
	{ Update(COptionalVariant(), COptionalVariant()); } 
 
	void Offset(double deltaX, double deltaY); 
	void Attach(LPDISPATCH Map); 
	CMapXFeature Clone(); 
 
	VARIANT Nodes(const VARIANT& CSys); 
	VARIANT Nodes() 
	{ return Nodes(COptionalVariant()); } 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXFeatures wrapper class 
 
class CMapXFeatures : public COleDispatchDriver 
{ 
public: 
	CMapXFeatures() {}		// Calls COleDispatchDriver default constructor 
	CMapXFeatures(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXFeatures(const CMapXFeatures& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXFeature operator[](long Index) { return Item(Index); } 
 
// Attributes 
public: 
	long GetCount(); 
	CMapXRectangle GetBounds(); 
 
// Operations 
public: 
	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 AddByID(const VARIANT& FeatureID); 
	void AddByID(long FeatureID) 
	{ AddByID(COleVariant(FeatureID)); } 
	void AddByID(LPCTSTR FeatureID) 
	{ AddByID(COleVariant(FeatureID)); } 
 
	void RemoveByID(const VARIANT& FeatureID); 
	void RemoveByID(long FeatureID) 
	{ RemoveByID(COleVariant(FeatureID)); } 
	void RemoveByID(LPCTSTR FeatureID) 
	{ RemoveByID(COleVariant(FeatureID)); } 
	 
	void Add(LPDISPATCH Source); 
	void Common(LPDISPATCH Source); 
	void Replace(LPDISPATCH Source); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXLayer wrapper class 
 
class CMapXLayer : public COleDispatchDriver 
{ 
public: 
	CMapXLayer() {}		// Calls COleDispatchDriver default constructor 
	CMapXLayer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXLayer(const CMapXLayer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CString GetName(); 
	void SetName(LPCTSTR); 
	BOOL GetVisible(); 
	void SetVisible(BOOL); 
	BOOL GetSelectable(); 
	void SetSelectable(BOOL); 
	CString GetFilespec(); 
	CMapXLabelProperties GetLabelProperties(); 
	CMapXLabelProperties GetLabel() { return GetLabelProperties(); } 
	BOOL GetAutoLabel(); 
	void SetAutoLabel(BOOL); 
	BOOL GetZoomLayer(); 
	void SetZoomLayer(BOOL); 
	BOOL GetOverrideStyle(); 
	void SetOverrideStyle(BOOL); 
	CMapXStyle GetStyle(); 
	void SetStyle(LPDISPATCH); 
	double GetZoomMin(); 
	void SetZoomMin(double); 
	double GetZoomMax(); 
	void SetZoomMax(double); 
	CMapXSelection GetSelection(); 
	short GetPredominantFeatureType(); 
	CMapXLayerFind GetFind(); 
	short GetType(); 
	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: 
	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(); 
	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); 
	CMapXLayer GetLayer(); 
	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: 
	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 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()); } 
	BOOL GetShowEmptyRanges(); 
	void SetShowEmptyRanges(BOOL); 
	void ExportLegend(LPCTSTR Destination, short Format); 
	BOOL GetShowCount(); 
	void SetShowCount(BOOL propVal); 
	double GetPaperHeight(); 
	double GetPaperWidth(); 
	void PrintLegend(long hDC, long X, long Y, long W, long H); 
		 
// Operations 
public: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// 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: 
	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: 
	long GetCount(); 
 
// 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); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// 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) {} 
 
	CMapXField operator[](long Index) { return Item(Index); } 
	CMapXField operator[](LPCTSTR Index) { return Item(Index); } 
 
	CLSID const& GetClsid() 
	{ 
 
	static CLSID clsid = 
	{ 0x9d6ed186, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	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(); 
}; 
 
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); 
	short GetLineWidthUnit(); 
	void SetLineWidthUnit(short nNewValue); 
	short GetRegionBorderWidthUnit(); 
	void SetRegionBorderWidthUnit(short nNewValue); 
	BOOL GetLineSupportsInterleave(); 
	void SetTextFontRotation(short propVal); 
	short GetTextFontRotation(); 
	unsigned long GetSymbolVectorColor(); 
	void SetSymbolVectorColor(unsigned long); 
	short GetSymbolVectorSize(); 
	void SetSymbolVectorSize(short); 
	short GetMinVectorSymbolCharacter(); 
	void SetMinVectorSymbolCharacter(short); 
	short GetMaxVectorSymbolCharacter(); 
	void SetMaxVectorSymbolCharacter(short); 
 
// 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() {}		// Calls COleDispatchDriver default constructor 
	CMapXGraphic(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXGraphic(const CMapXGraphic& 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: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXLegendText wrapper class 
 
class CMapXLegendText : public COleDispatchDriver 
{ 
public: 
	CMapXLegendText() {}		// Calls COleDispatchDriver default constructor 
	CMapXLegendText(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXLegendText(const CMapXLegendText& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CString GetText(); 
	void SetText(LPCTSTR); 
 	BOOL GetVisible(); 
	void SetVisible(BOOL bNewValue); 
 
// Operations 
public: 
}; 
///////////////////////////////////////////////////////////////////////////// 
// CMapXLegendTexts wrapper class 
 
class CMapXLegendTexts : public COleDispatchDriver 
{ 
public: 
	CMapXLegendTexts() {}		// Calls COleDispatchDriver default constructor 
	CMapXLegendTexts(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXLegendTexts(const CMapXLegendTexts& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXLegendText operator[](long Index) { return Item(Index); } 
 
	// Attributes 
public: 
	BOOL GetAutoGenerate(); 
	void SetAutoGenerate(BOOL); 
	long GetCount(); 
	CMapXLegendText GetAllOthersText(); 
 
// Operations 
public: 
	CMapXLegendText Item(const VARIANT& Index); 
	CMapXLegendText Item(long Index) { return Item(COleVariant(Index)); } 
}; 
///////////////////////////////////////////////////////////////////////////// 
// CMapXTitle wrapper class 
 
class CMapXTitle : public COleDispatchDriver 
{ 
public: 
	CMapXTitle() {}		// Calls COleDispatchDriver default constructor 
	CMapXTitle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXTitle(const CMapXTitle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CString GetCaption(); 
	void SetCaption(LPCTSTR); 
	CMapXStyle GetTextStyle(); 
	void SetTextStyle(LPDISPATCH); 
	BOOL GetVisible(); 
	void SetVisible(BOOL); 
	double GetX(); 
	void SetX(double); 
	double GetY(); 
	void SetY(double); 
	BOOL GetEditable(); 
	void SetEditable(BOOL); 
	short GetPosition(); 
	void SetPosition(short); 
	BOOL GetBorder(); 
	void SetBorder(BOOL); 
 
// Operations 
public: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXBindLayer wrapper class 
 
class CMapXBindLayer : public COleDispatchDriver 
{ 
public: 
	CMapXBindLayer() {}		// Calls COleDispatchDriver default constructor 
	CMapXBindLayer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXBindLayer(const CMapXBindLayer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CLSID const& GetClsid() 
	{ 
 
	static CLSID clsid = 
	{ 0x9d6ed182, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca} }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	CString GetLayerName(); 
	void SetLayerName(LPCTSTR); 
	VARIANT GetRefColumn1(); 
	void SetRefColumn1(const VARIANT&); 
	void SetRefColumn1(long Column) { SetRefColumn1(COleVariant(Column)); } 
	void SetRefColumn1(LPCTSTR Column) { SetRefColumn1(COleVariant(Column)); } 
	VARIANT GetRefColumn2(); 
	void SetRefColumn2(const VARIANT&); 
	void SetRefColumn2(long Column) { SetRefColumn2(COleVariant(Column)); } 
	void SetRefColumn2(LPCTSTR Column) { SetRefColumn2(COleVariant(Column)); } 
	short GetLayerType(); 
	void SetLayerType(short); 
	CString GetReferenceLayer(); 
	void SetReferenceLayer(LPCTSTR); 
	CMapXCoordSys GetCoordSys(); 
	void SetCoordSys(LPDISPATCH); 
	CString GetFilespec(); 
	void SetFilespec(LPCTSTR); 
	short GetKeyLength(); 
	void SetKeyLength(short); 
	long GetReferenceLayerField(); 
	void SetReferenceLayerField(long); 
 
// Operations 
public: 
}; 
///////////////////////////////////////////////////////////////////////////// 
// CMapXMultivarCategories wrapper class 
 
class CMapXMultivarCategories : public COleDispatchDriver 
{ 
public: 
	CMapXMultivarCategories() {}		// Calls COleDispatchDriver default constructor 
	CMapXMultivarCategories(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXMultivarCategories(const CMapXMultivarCategories& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXMultivarCategory operator[](long Index) { return Item(Index); } 
 
// Attributes 
public: 
	long GetCount(); 
 
// Operations 
public: 
	CMapXMultivarCategory Item(const VARIANT& Index); 
	CMapXMultivarCategory Item(long Index) { return Item(COleVariant(Index)); } 
}; 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXRangeCategories wrapper class 
 
class CMapXRangeCategories : public COleDispatchDriver 
{ 
public: 
	CMapXRangeCategories() {}		// Calls COleDispatchDriver default constructor 
	CMapXRangeCategories(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXRangeCategories(const CMapXRangeCategories& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXRangeCategory operator[](long Index) { return Item(Index); } 
 
// Attributes 
public: 
	long GetCount(); 
    CMapXRangeCategory GetAllOthersCategory(); 
 
// Operations 
public: 
	CMapXRangeCategory Item(const VARIANT& Index); 
	CMapXRangeCategory Item(long Index) { return Item(COleVariant(Index)); } 
}; 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXIndividualValueCategories  wrapper class 
 
class CMapXIndividualValueCategories : public COleDispatchDriver 
{ 
public: 
	CMapXIndividualValueCategories () {}		// Calls COleDispatchDriver default constructor 
	CMapXIndividualValueCategories (LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXIndividualValueCategories (const CMapXIndividualValueCategories & dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXIndividualValueCategory operator[](long Index) { return Item(Index); } 
 
// Attributes 
public: 
	long GetCount(); 
    CMapXIndividualValueCategory GetAllOthersCategory(); 
 
// Operations 
public: 
	CMapXIndividualValueCategory Item(const VARIANT& Index); 
	CMapXIndividualValueCategory Item(long Index) { return Item(COleVariant(Index)); } 
}; 
 
 
// CMapXRectangle wrapper class 
 
class CMapXRectangle : public COleDispatchDriver 
{ 
public: 
	CMapXRectangle() {}		// Calls COleDispatchDriver default constructor 
	CMapXRectangle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXRectangle(const CMapXRectangle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
    CLSID const& GetClsid() 
	{ 
    static CLSID clsid = 
		{ 0x9d6ed191, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
// Attributes 
public: 
	double GetXMin(); 
	double GetYMin(); 
	double GetXMax(); 
	double GetYMax(); 
	double GetHeight(); 
	double GetWidth(); 
 
// Operations 
public: 
	void Set(double X1, double Y1, double X2, double Y2); 
	void Offset(double deltaX, double deltaY); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXFindFeature wrapper class 
 
class CMapXFindFeature : public COleDispatchDriver 
{ 
public: 
	CMapXFindFeature() {}		// Calls COleDispatchDriver default constructor 
	CMapXFindFeature(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXFindFeature(const CMapXFindFeature& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	short GetFindRC(); 
	long GetFeatureID(); 
	short GetType(); 
	void SetType(short); 
	double GetLength(); 
	double GetCenterX(); 
	double GetCenterY(); 
	CMapXStyle GetStyle(); 
	void SetStyle(LPDISPATCH); 
	CMapXRectangle GetBounds(); 
	CMapXParts GetParts(); 
	double GetArea(); 
	CMapXLayer GetLayer(); 
	CString GetCaption(); 
	void SetCaption(LPCTSTR); 
	CMapXPoint GetPoint(); 
	void SetPoint(LPDISPATCH); 
	CMapXPoint GetLabelPoint(); 
	double GetPerimeter(); 
	BOOL GetSmooth(); 
	void SetSmooth(BOOL); 
	CString GetName(); 
	CString GetKeyValue(); 
	void SetKeyValue(LPCTSTR); 
 
// Operations 
public: 
	void Update(); 
	void Offset(double deltaX, double deltaY); 
 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXFindResult wrapper class 
 
class CMapXFindResult : public COleDispatchDriver 
{ 
public: 
	CMapXFindResult() {}		// Calls COleDispatchDriver default constructor 
	CMapXFindResult(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXFindResult(const CMapXFindResult& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	 BOOL GetExactMatch(); 
	 BOOL GetSubstitute(); 
	 BOOL GetAddressOutOfRange(); 
	 BOOL GetIntersectionNotFound(); 
	 BOOL GetMultipleMatches(); 
	 BOOL GetRefineRegion(); 
	 short GetFindRC(); 
	 CMapXFindMatches GetMatches(); 
	 CMapXFeature GetMatchedFeature(); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXLayerFind wrapper class 
 
class CMapXLayerFind : public COleDispatchDriver 
{ 
public: 
	CMapXLayerFind() {}		// Calls COleDispatchDriver default constructor 
	CMapXLayerFind(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXLayerFind(const CMapXLayerFind& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CMapXLayer GetRefineLayer(); 
	void SetRefineLayer(CMapXLayer); 
	BOOL GetAbbreviations(); 
	void SetAbbreviations(BOOL); 
	BOOL GetClosestAddr(); 
	void SetClosestAddr(BOOL); 
	BOOL GetOtherBoundary(); 
	void SetOtherBoundary(BOOL); 
	CMapXField GetFindField(); 
	void SetFindField(CMapXField); 
	CMapXField GetRefineField(); 
	void SetRefineField(CMapXField); 
	CMapXDataset GetFindDataset(); 
	void SetFindDataset(CMapXDataset); 
	CMapXDataset GetRefineDataset(); 
	void SetRefineDataset(CMapXDataset); 
	long GetCloseMatchMax(); 
	void SetCloseMatchMax(long); 
 
// Operations 
public: 
	CMapXFindFeature Search(LPCTSTR Address, const VARIANT& RefineBoundary); 
	CMapXFindFeature Search(LPCTSTR Address, LPCTSTR RefineBoundary) 
	{ return Search(Address, COleVariant(RefineBoundary)); } 
	CMapXFindFeature Search(LPCTSTR Address) 
	{ return Search(Address, COptionalVariant()); } 
 
	CMapXFindResult SearchEx(LPCTSTR Address, const VARIANT& RefineBoundary); 
	CMapXFindResult SearchEx(LPCTSTR Address, LPCTSTR RefineBoundary) 
	{ return SearchEx(Address, COleVariant(RefineBoundary)); } 
	CMapXFindResult SearchEx(LPCTSTR Address) 
	{ return SearchEx(Address, COptionalVariant()); } 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXFindMatches wrapper class 
 
class CMapXFindMatch : public COleDispatchDriver 
{ 
public: 
	CMapXFindMatch() {}		// Calls COleDispatchDriver default constructor 
	CMapXFindMatch(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXFindMatch(const CMapXFindMatch& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	long GetFeatureID(); 
	CString  GetName(); 
	long GetScore(); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXFindMatches wrapper class 
 
class CMapXFindMatches : public COleDispatchDriver 
{ 
public: 
	CMapXFindMatches() {}		// Calls COleDispatchDriver default constructor 
	CMapXFindMatches(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXFindMatches(const CMapXFindMatches& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CMapXFindMatch operator[](long Index) { return Item(Index); } 
 
// Attributes 
public: 
	long GetCount(); 
 
// Operations 
public: 
	CMapXFindMatch Item(const VARIANT& Index); 
	CMapXFindMatch Item(long Index) { return Item(COleVariant(Index)); } 
 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXGeoset wrapper class 
 
class CMapXGeoset : public COleDispatchDriver 
{ 
public: 
	CMapXGeoset() {}		// Calls COleDispatchDriver default constructor 
	CMapXGeoset(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXGeoset(const CMapXGeoset& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CMapXPoint GetCentroid(); 
	CString GetPathName(); 
	CString GetUserName(); 
 
// Operations 
public: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXGeosets wrapper class 
 
class CMapXGeosets : public COleDispatchDriver 
{ 
public: 
	CMapXGeosets() {}		// Calls COleDispatchDriver default constructor 
	CMapXGeosets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXGeosets(const CMapXGeosets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXGeoset operator[](long Index) { return Item(Index); } 
	CMapXGeoset operator[](LPCTSTR Index) { return Item(Index); } 
 
// Attributes 
public: 
	long GetCount(); 
 
// Operations 
public: 
	CMapXGeoset Item(const VARIANT& Index); 
	CMapXGeoset Item(long Index) { return Item(COleVariant(Index)); } 
	CMapXGeoset Item(LPCTSTR Index) { return Item(COleVariant(Index)); } 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXPoint wrapper class 
 
class CMapXPoint : public COleDispatchDriver 
{ 
public: 
	CMapXPoint() {}		// Calls COleDispatchDriver default constructor 
	CMapXPoint(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXPoint(const CMapXPoint& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
 
	static CLSID clsid = 
	{ 0x9d6ed18b, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
 
// Attributes 
public: 
	double GetX(); 
	double GetY(); 
 
// Operations 
public: 
	void Set(double X, double Y); 
	void Offset(double deltaX, double deltaY); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXPoints wrapper class 
 
class CMapXPoints : public COleDispatchDriver 
{ 
public: 
	CMapXPoints() {}		// Calls COleDispatchDriver default constructor 
	CMapXPoints(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXPoints(const CMapXPoints& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXPoint operator[](long Index) { return Item(Index); } 
 
  CLSID const& GetClsid() 
	{ 
    static CLSID clsid = 
		{ 0x9d6ed18c, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	long GetCount(); 
 
// Operations 
public: 
	CMapXPoint Item(const VARIANT& Index); 
	CMapXPoint Item(long Index) { return Item(COleVariant(Index)); } 
	void Remove(const VARIANT& Index); 
	void Remove(long Index) { Remove(COleVariant(Index)); } 
	CMapXPoint Add(LPDISPATCH Point, const VARIANT& Position); 
	CMapXPoint Add(LPDISPATCH Point, short Position) { return Add(Point, COleVariant(Position)); } 
	CMapXPoint Add(LPDISPATCH Point) { return Add(Point, COptionalVariant()); } 
	CMapXPoint AddXY(double X, double Y, const VARIANT& Position); 
	CMapXPoint AddXY(double X, double Y) { return AddXY(X,Y, COptionalVariant()); } 
	CMapXPoint AddXY(double X, double Y, short Position) { return AddXY(X,Y, COleVariant(Position)); } 
	void RemoveAll(); 
 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXParts wrapper class 
 
class CMapXParts : public COleDispatchDriver 
{ 
public: 
	CMapXParts() {}		// Calls COleDispatchDriver default constructor 
	CMapXParts(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXParts(const CMapXParts& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CMapXPoints operator[](long Index) { return Item(Index); } 
 
  CLSID const& GetClsid() 
	{ 
    static CLSID clsid = 
		{ 0x9d6ed18a, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	long GetCount(); 
 
// Operations 
public: 
	CMapXPoints Add(LPDISPATCH Points); 
	CMapXPoints Add() { return Add(NULL); } 
	CMapXPoints Item(const VARIANT& Index); 
	CMapXPoints Item(long Index) { return Item(COleVariant(Index)); } 
	void Remove(const VARIANT& Index); 
	void Remove(long Index) { Remove(COleVariant(Index)); } 
	void RemoveAll(); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXNotesViewInfo wrapper class 
 
class CMapXNotesViewInfo : public COleDispatchDriver 
{ 
public: 
	CMapXNotesViewInfo() {}		// Calls COleDispatchDriver default constructor 
	CMapXNotesViewInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXNotesViewInfo(const CMapXNotesViewInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
		// {DA1EA908-85C3-11d0-83F2-00AA00BD34FC} 
    static CLSID clsid = 
		{ 0x9d6ed196, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	CString GetServer(); 
	void SetServer(LPCTSTR); 
	CString GetDatabase(); 
	void SetDatabase(LPCTSTR); 
	CString GetView(); 
	void SetView(LPCTSTR); 
 
// Operations 
public: 
}; 
///////////////////////////////////////////////////////////////////////////// 
// CMapXNotesQueryInfo wrapper class 
 
class CMapXNotesQueryInfo : public COleDispatchDriver 
{ 
public: 
	CMapXNotesQueryInfo() {}		// Calls COleDispatchDriver default constructor 
	CMapXNotesQueryInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXNotesQueryInfo(const CMapXNotesQueryInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
		// {F4BBB761-9403-11D0-96AF-00AA00A4760F} 
    static CLSID clsid = 
		{ 0x9d6ed195, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	CString GetServer(); 
	void SetServer(LPCTSTR); 
	CString GetDatabase(); 
	void SetDatabase(LPCTSTR); 
	CString GetQuery(); 
	void SetQuery(LPCTSTR); 
	CString GetBeginDate(); 
	void SetBeginDate(LPCTSTR); 
	CString GetEndDate(); 
	void SetEndDate(LPCTSTR); 
	BOOL GetFullTextSearch(); 
	void SetFullTextSearch(BOOL); 
	CString GetDefaultStringValue(); 
	void SetDefaultStringValue(LPCTSTR); 
	double GetDefaultNumericValue(); 
	void SetDefaultNumericValue(double); 
	long GetMaxNumDocs(); 
	void SetMaxNumDocs(long); 
 
// Operations 
public: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXODBCQueryInfo wrapper class 
 
class CMapXODBCQueryInfo : public COleDispatchDriver 
{ 
public: 
	CMapXODBCQueryInfo() {}		// Calls COleDispatchDriver default constructor 
	CMapXODBCQueryInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXODBCQueryInfo(const CMapXODBCQueryInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
    static CLSID clsid = 
		{ 0x9d6ed194, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca} }; 
 
		return clsid; 
	} 
 
 
	// Attributes 
public: 
	CString GetDataSource(); 
	void SetDataSource(LPCTSTR); 
	CString GetSqlQuery(); 
	void SetSqlQuery(LPCTSTR); 
	CString GetConnectString(); 
	void SetConnectString(LPCTSTR); 
 
// Operations 
public: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXDatum wrapper class 
 
class CMapXDatum : public COleDispatchDriver 
{ 
public: 
	CMapXDatum() {}		// Calls COleDispatchDriver default constructor 
	CMapXDatum(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXDatum(const CMapXDatum& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CLSID const& GetClsid() 
	{ 
 
	static CLSID clsid = 
	{ 0x9d6ed185, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
		return clsid; 
	} 
 
// Attributes 
public: 
	short GetEllipsoid(); 
	double GetShiftX(); 
	double GetShiftY(); 
	double GetShiftZ(); 
	double GetRotateX(); 
	double GetRotateY(); 
	double GetRotateZ(); 
	double GetScaleAdjust(); 
	double GetPrimeMeridian(); 
	double GetSemiMajorAxis(); 
	double GetSemiMinorAxis(); 
	double GetFlattening(); 
	double GetEccentricity(); 
 
// Operations 
public: 
	void Set(short Ellipsoid, double ShiftX, double ShiftY, double ShiftZ, double RotateX, double RotateY, double RotateZ, double ScaleAdjust, double PrimeMeridian); 
	void SetFromList(short DatumNum); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// CMapXAffineTransform wrapper class 
 
class CMapXAffineTransform : public COleDispatchDriver 
{ 
public: 
	CMapXAffineTransform() {}		// Calls COleDispatchDriver default constructor 
	CMapXAffineTransform(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXAffineTransform(const CMapXAffineTransform& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CLSID const& GetClsid() 
	{ 
		static CLSID clsid = { 0x9d6ed181, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca} }; 
		return clsid; 
	} 
 
// Attributes 
public: 
	short GetUnits(); 
	double GetA(); 
	double GetB(); 
	double GetC(); 
	double GetD(); 
	double GetE(); 
	double GetF(); 
 
// Operations 
public: 
	void Set(short Units, double A, double B, double C, double D, double E, double F); 
}; 
///////////////////////////////////////////////////////////////////////////// 
// CMapXCoordSys wrapper class 
 
class CMapXCoordSys : public COleDispatchDriver 
{ 
public: 
	CMapXCoordSys() {}		// Calls COleDispatchDriver default constructor 
	CMapXCoordSys(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXCoordSys(const CMapXCoordSys& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CLSID const& GetClsid() 
	{ 
 
	static CLSID clsid = 
	{ 0x9d6ed183, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
		return clsid; 
	} 
 
// Attributes 
public: 
	short GetType(); 
	CMapXDatum GetDatum(); 
	short GetUnits(); 
	CMapXRectangle GetBounds(); 
	double GetOriginLongitude(); 
	double GetOriginLatitude(); 
	double GetStandardParallelOne(); 
	double GetStandardParallelTwo(); 
	double GetAzimuth(); 
	double GetScaleFactor(); 
	double GetFalseEasting(); 
	double GetFalseNorthing(); 
	double GetRange(); 
	CMapXAffineTransform GetAffineTransform(); 
 
// Operations 
public: 
	void Set(short Type, const VARIANT& Datum, const VARIANT& Units, const VARIANT& OriginLongitude, const VARIANT& OriginLatitude, const VARIANT& StandardParallelOne, const VARIANT& StandardParallelTwo, const VARIANT& Azimuth, 
		const VARIANT& ScaleFactor, const VARIANT& FalseEasting, const VARIANT& FalseNorthing, const VARIANT& Range, const VARIANT& Bounds, const VARIANT& AffineTransform); 
	 
	void Set(short Type, LPDISPATCH Datum, const VARIANT& Units, const VARIANT& OriginLongitude, const VARIANT& OriginLatitude, const VARIANT& StandardParallelOne, const VARIANT& StandardParallelTwo, const VARIANT& Azimuth, 
		const VARIANT& ScaleFactor, const VARIANT& FalseEasting, const VARIANT& FalseNorthing, const VARIANT& Range, const VARIANT& Bounds, const VARIANT& AffineTransform) 
		{ 
			Set(Type, COleVariantDispatch(Datum), Units, OriginLongitude, OriginLatitude, StandardParallelOne, 
				StandardParallelTwo, Azimuth, ScaleFactor, FalseEasting, FalseNorthing, Range, Bounds, 
				AffineTransform); 
		} 
 
	void Set(short Type, short Datum, const VARIANT& Units, const VARIANT& OriginLongitude, const VARIANT& OriginLatitude, const VARIANT& StandardParallelOne, const VARIANT& StandardParallelTwo, const VARIANT& Azimuth, 
		const VARIANT& ScaleFactor, const VARIANT& FalseEasting, const VARIANT& FalseNorthing, const VARIANT& Range, const VARIANT& Bounds, const VARIANT& AffineTransform) 
		{ 
			Set(Type, COleVariant(Datum), Units, OriginLongitude, OriginLatitude, StandardParallelOne, 
				StandardParallelTwo, Azimuth, ScaleFactor, FalseEasting, FalseNorthing, Range, Bounds, 
				AffineTransform); 
		} 
 
	BOOL PickCoordSys(const VARIANT& HelpFile, const VARIANT& HelpID); 
	BOOL PickCoordSys(LPCTSTR HelpFile, UINT HelpID=HELP_FINDER) 
		{ return PickCoordSys(COleVariant(HelpFile), COleVariant((long)HelpID)); } 
	BOOL PickCoordSys() 
		{ return PickCoordSys(COptionalVariant(), COptionalVariant()); } 
 
  CMapXCoordSys Clone(); 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXBitmapSymbol wrapper class 
 
class CMapXBitmapSymbol : public COleDispatchDriver 
{ 
public: 
	CMapXBitmapSymbol() {}		// Calls COleDispatchDriver default constructor 
	CMapXBitmapSymbol(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXBitmapSymbol(const CMapXBitmapSymbol& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CString GetName(); 
}; 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXBitmapSymbols wrapper class 
 
class CMapXBitmapSymbols : public COleDispatchDriver 
{ 
public: 
	CMapXBitmapSymbols() {}		// Calls COleDispatchDriver default constructor 
	CMapXBitmapSymbols(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXBitmapSymbols(const CMapXBitmapSymbols& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
	CLSID const& GetClsid() 
	{ 
 
	static CLSID clsid = 
	{ 0x9d6ed184, 0x5910, 0x11d2, { 0x98, 0xa6, 0x0, 0xa0, 0xc9, 0x74, 0x2c, 0xca } }; 
 
		return clsid; 
	} 
 
// Attributes 
public: 
	long GetCount(); 
	CMapXBitmapSymbol operator[](long Index) { return Item(Index); } 
 
// Operations 
public: 
	CMapXBitmapSymbol Item(const VARIANT& Index); 
	CMapXBitmapSymbol Item(long Index) { return Item(COleVariant(Index)); } 
	void Refresh(); 
	void Unload(); 
 
 
// Operations 
public: 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXFeatureFactory wrapper class 
 
class CMapXFeatureFactory : public COleDispatchDriver 
{ 
public: 
	CMapXFeatureFactory() {}		// Calls COleDispatchDriver default constructor 
	CMapXFeatureFactory(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXFeatureFactory(const CMapXFeatureFactory& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
 
// Operations 
public: 
	CMapXFeature BufferFeatures(LPDISPATCH Source, double Distance, const VARIANT& Units, const VARIANT& Resolution); 
	CMapXFeature BufferFeatures(LPDISPATCH Source, double Distance, short Units, short Resolution) 
		{ return BufferFeatures(Source, Distance, COleVariant(Units), COleVariant(Resolution));} 
	CMapXFeature BufferFeatures(LPDISPATCH Source, double Distance, short Units) 
		{ return BufferFeatures(Source, Distance, COleVariant(Units), COptionalVariant());} 
 
	CMapXFeature CombineFeatures(LPDISPATCH Source1, const VARIANT& Source2); 
	CMapXFeature CombineFeatures(LPDISPATCH Source1) 
		{ return CombineFeatures(Source1, COptionalVariant()); } 
 
	CMapXFeature IntersectFeatures(LPDISPATCH Source1, const VARIANT& Source2); 
	CMapXFeature IntersectFeatures(LPDISPATCH Source1) 
		{ return IntersectFeatures(Source1, COptionalVariant()); } 
 
	CMapXFeature EraseFeature(LPDISPATCH Feature, LPDISPATCH EraserFeature); 
 
	CMapXFeature CreateSymbol(const VARIANT& Point, const VARIANT& Style); 
	CMapXFeature CreateSymbol(const VARIANT& Point) 
		{ return CreateSymbol(Point, COptionalVariant());} 
	CMapXFeature CreateSymbol() 
		{ return CreateSymbol(COptionalVariant(), COptionalVariant());} 
 
	CMapXFeature CreateRegion(const VARIANT& Points, const VARIANT& Style); 
	CMapXFeature CreateRegion(const VARIANT& Points) 
		{ return CreateRegion(Points, COptionalVariant());} 
	CMapXFeature CreateRegion() 
		{ return CreateRegion(COptionalVariant(), COptionalVariant());} 
 
	CMapXFeature CreateLine(const VARIANT& Points, const VARIANT& Style); 
	CMapXFeature CreateLine(const VARIANT& Points) 
		{ return CreateLine(Points, COptionalVariant());} 
	CMapXFeature CreateLine() 
		{ return CreateLine(COptionalVariant(), COptionalVariant());} 
 
	CMapXFeature CreateText(const VARIANT& Point, const VARIANT& Caption, const VARIANT& Position, const VARIANT& Style); 
	CMapXFeature CreateText(const VARIANT& Point, LPCTSTR Caption, short Position, const VARIANT& Style) 
		{ return CreateText(Point, COleVariant(Caption), COleVariant(Position), Style);} 
	CMapXFeature CreateText(const VARIANT& Point, LPCTSTR Caption="", short Position=miPositionTL) 
		{ return CreateText(Point, COleVariant(Caption), COleVariant(Position), COptionalVariant());} 
	CMapXFeature CreateText(LPCTSTR Caption="", short Position=miPositionTL) 
		{ return CreateText(COptionalVariant(), COleVariant(Caption), COleVariant(Position), COptionalVariant());} 
 
	CMapXFeature CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, const VARIANT& Angle, const VARIANT& Distance, const VARIANT& Resolution, const VARIANT& Style); 
	CMapXFeature CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, double Angle, double Distance, short Resolution) 
		{ return CreateArc(Point1, Point2, COleVariant(Angle), COleVariant(Distance), COleVariant(Resolution), COptionalVariant());} 
	CMapXFeature CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, double Angle=90.0, double Distance=1.0) 
		{ return CreateArc(Point1, Point2, COleVariant(Angle), COleVariant(Distance), COptionalVariant(), COptionalVariant());} 
 
	CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, const VARIANT& Angle, const VARIANT& Resolution, const VARIANT& Style); 
	CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, double Angle=0.0) 
	{ return CreateEllipticalRegion(Rectangle, COleVariant(Angle), COptionalVariant(), COptionalVariant());} 
	CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, short Resolution) 
	{ return CreateEllipticalRegion(Rectangle, COptionalVariant(), COleVariant(Resolution), COptionalVariant());} 
	CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, LPDISPATCH Style) 
	{ 
		return CreateEllipticalRegion(Rectangle, COptionalVariant(), COptionalVariant(), COleVariantDispatch(Style)); 
	} 
	CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, double Angle, short Resolution) 
	{ return CreateEllipticalRegion(Rectangle, COleVariant(Angle), COleVariant(Resolution), COptionalVariant());} 
	CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, double Angle, LPDISPATCH Style) 
	{ 
		return CreateEllipticalRegion(Rectangle, COleVariant(Angle), COptionalVariant(), COleVariantDispatch(Style)); 
	} 
	CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, short Resolution, LPDISPATCH Style) 
	{ 
		return CreateEllipticalRegion(Rectangle, COptionalVariant(), COleVariant(Resolution), COleVariantDispatch(Style)); 
	} 
	CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, double Angle, short Resolution, LPDISPATCH Style) 
	{ 
		return CreateEllipticalRegion(Rectangle, COleVariant(Angle), COleVariant(Resolution), COleVariantDispatch(Style)); 
	} 
 
	CMapXFeature CreateCircularRegion(short Type, LPDISPATCH Point, double Distance, const VARIANT& Units, const VARIANT& Resolution, const VARIANT& Style); 
	CMapXFeature CreateCircularRegion(short Type, LPDISPATCH Point, double Distance, short Units, short Resolution) 
		{ return CreateCircularRegion(Type, Point, Distance, COleVariant(Units), COleVariant(Resolution), COptionalVariant());} 
	CMapXFeature CreateCircularRegion(short Type, LPDISPATCH Point, double Distance, short Units) 
		{ return CreateCircularRegion(Type, Point, Distance, COleVariant(Units), COptionalVariant(), COptionalVariant());} 
 
	BOOL IntersectionTest(LPDISPATCH Feature1, LPDISPATCH Feature2, const VARIANT& Flag); 
	BOOL IntersectionTest(LPDISPATCH Feature1, LPDISPATCH Feature2, short Flag=miIntersectFeature) 
		{ return IntersectionTest(Feature1, Feature2, COleVariant(Flag)); } 
 
	CMapXPoints IntersectionPoints(LPDISPATCH Feature1, LPDISPATCH Feature2, const VARIANT& Flag); 
	CMapXPoints IntersectionPoints(LPDISPATCH Feature1, LPDISPATCH Feature2, short Flag=miIntersectAll) 
		{ return IntersectionPoints(Feature1, Feature2, COleVariant(Flag)); } 
}; 
 
class CMapXResolveObject : public COleDispatchDriver 
{ 
public: 
	CMapXResolveObject() {}		// Calls COleDispatchDriver default constructor 
	CMapXResolveObject(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXResolveObject(const CMapXResolveObject& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
 
// Attributes 
public: 
	CString GetTableName(); 
	long GetSourceMatch(); 
	long GetTableMatch(); 
 
// Operations 
public: 
}; 
 
class CMapXResolveObjects : public COleDispatchDriver 
{ 
public: 
	CMapXResolveObjects() {}		// Calls COleDispatchDriver default constructor 
	CMapXResolveObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXResolveObjects(const CMapXResolveObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
 
// Attributes 
public: 
	long GetCount(); 
	CMapXResolveObject operator[](long Index) { return Item(Index); } 
 
// Operations 
public: 
	CMapXResolveObject Item(const VARIANT& Index); 
	CMapXResolveObject Item(long Index) { return Item(COleVariant(Index)); } 
}; 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXLayerInfo wrapper class 
 
class CMapXLayerInfo : public COleDispatchDriver 
{ 
public: 
	CMapXLayerInfo() {}		// Calls COleDispatchDriver default constructor 
	CMapXLayerInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXLayerInfo(const CMapXRowValue& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
		static CLSID clsid = 
		{ 0x30d28171, 0xfe33, 0x11d2, { 0x98, 0x78, 0x0, 0x60, 0x08, 0x9f, 0x59, 0xa5} }; 
		return clsid; 
	} 
 
// Attributes 
public: 
	short GetType(); 
	void SetType(short); 
 
// Operations 
public: 
	void AddParameter(LPCTSTR ParamName, const VARIANT& Param); 
}; 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CMapXVariable wrapper class 
 
class CMapXVariable : public COleDispatchDriver 
{ 
public: 
	CMapXVariable() {}		// Calls COleDispatchDriver default constructor 
	CMapXVariable(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXVariable(const CMapXVariable& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
// Attributes 
public: 
	CString GetName(); 
	VARIANT GetValue(); 
	void SetValue(const VARIANT&); 
	void SetValue(short n) 
		{ SetValue(COleVariant(n)); } 
	void SetValue(long n) 
		{ SetValue(COleVariant(n)); } 
	void SetValue(double d) 
		{ SetValue(COleVariant(d)); } 
	void SetValue(const char *pszValue) 
		{ SetValue(COleVariant(pszValue)); } 
 
// Operations 
public: 
}; 
 
 
// CMapXVariables wrapper class 
 
class CMapXVariables : public COleDispatchDriver 
{ 
public: 
	CMapXVariables() {}		// Calls COleDispatchDriver default constructor 
	CMapXVariables(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {} 
	CMapXVariables(const CMapXVariables& dispatchSrc) : COleDispatchDriver(dispatchSrc) {} 
 
  CLSID const& GetClsid() 
	{ 
		static CLSID clsid = 
		{	0x9a5d5584, 0xefb8, 0x11d3, { 0x9c, 0x33, 0x0, 0x50, 0x4, 0x9d, 0xa6, 0x82 } }; 
		return clsid; 
	} 
 
// Attributes 
public: 
	long GetCount(); 
	CMapXVariable operator[](long Index) { return Item(Index); } 
	CMapXVariable operator[](LPCTSTR Index) { return Item(Index); } 
 
// Operations 
public: 
	CMapXVariable Add(LPCTSTR Name, const VARIANT& Value); 
	CMapXVariable Add(LPCTSTR Name, long Value)  
		{ return Add(Name, COleVariant(Value)); } 
	CMapXVariable Add(LPCTSTR Name, short Value)  
		{ return Add(Name, COleVariant(Value)); } 
	CMapXVariable Add(LPCTSTR Name, double Value)  
		{ return Add(Name, COleVariant(Value)); } 
	CMapXVariable Add(LPCTSTR Name, LPCTSTR Value)  
		{ return Add(Name, COleVariant(Value)); } 
 
	 
	CMapXVariable Item(const VARIANT& Index); 
	CMapXVariable Item(long Index) { return Item(COleVariant(Index)); } 
	CMapXVariable 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(); 
	CMapXVariables Clone(); 
}; 
 
#endif // __MAPX_H__/////////////////////////////////////////////////////////////////////////////