mapx.h

GPS导航的源代码

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