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:
	LPENUMVARIANT GetEnumerator();

	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:
	LPENUMVARIANT GetEnumerator();

	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:
	LPENUMVARIANT GetEnumerator();

	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 GetNodes(const VARIANT& CSys);
	VARIANT GetNodes()
	{ return GetNodes(COptionalVariant()); }
	void SetNodes(const VARIANT& CSys, const VARIANT& newValue);

	// Obsolete. You should use GetNodes(CSys) instead:
	VARIANT Nodes(const VARIANT& CSys);
	// Obsolete. You should use GetNodes() instead:
	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:
	LPENUMVARIANT GetEnumerator();

	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);