开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
map.cpp
资源名称：MoLecture.rar　[点击查看]
上传用户：qinfarui
上传日期：2022-08-10
资源大小：362k
文件大小：11k
源码类别：

GIS编程

开发平台：

Visual C++

map.cpp：源码内容
  1. // Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
  3. // NOTE: Do not modify the contents of this file.  If this class is regenerated by
  4. //  Microsoft Visual C++, your modifications will be overwritten.
  7. #include "stdafx.h"
  8. #include "map.h"
  10. // Dispatch interfaces referenced by this interface
  11. #include "MoLayers.h"
  12. #include "MoRectangle.h"
  13. #include "motrackinglayer.h"
  14. #include "MoPoint.h"
  15. #include "moellipse.h"
  16. #include "MoLine.h"
  17. #include "mopolygon.h"
  18. #include "mogeodatasets.h"
  19. #include "MoDataConnection.h"
  20. #include "mogeodataset.h"
  21. #include "momaplayer.h"
  22. #include "morecordset.h"
  23. #include "MoFields.h"
  24. #include "MoField.h"
  25. #include "mopoints.h"
  26. #include "MoSymbol.h"
  27. #include "movaluemaprenderer.h"
  28. #include "MoStrings.h"
  29. #include "MoStatistics.h"
  30. #include "MoClassBreaksRenderer.h"
  31. #include "MoDotDensityRenderer.h"
  32. #include "MoLabelRenderer.h"
  33. #include "MoGeoEvent.h"
  34. #include "MoImageLayer.h"
  35. #include "motable.h"
  36. #include "MoTextSymbol.h"
  37. #include "MoTableDesc.h"
  38. #include "MoAddressLocation.h"
  39. #include "MoPlaceLocator.h"
  40. #include "moparts.h"
  41. #include "MoProjection.h"
  42. #include "MoProjCoordSys.h"
  43. #include "mogeocoordsys.h"
  44. #include "MoUnit.h"
  45. #include "modatum.h"
  46. #include "MoSpheroid.h"
  47. #include "MoPrimeMeridian.h"
  48. #include "mogeotransformation.h"
  49. #include "mostandardizer.h"
  50. #include "MoGeocoder.h"
  51. #include "MoZRenderer.h"
  52. #include "MoGroupRenderer.h"
  53. #include "MoChartRenderer.h"
  54. #include "MoLabelPlacer.h"
  55. #include "moeventrenderer.h"
  57. /////////////////////////////////////////////////////////////////////////////
  58. // CMap1
  60. IMPLEMENT_DYNCREATE(CMap1, CWnd)
  62. /////////////////////////////////////////////////////////////////////////////
  63. // CMap1 properties
  65. CMoLayers CMap1::GetLayers()
  66. {
  67. LPDISPATCH pDispatch;
  68. GetProperty(0x4, VT_DISPATCH, (void*)&pDispatch);
  69. return CMoLayers(pDispatch);
  70. }
  72. void CMap1::SetLayers(LPDISPATCH propVal)
  73. {
  74. SetProperty(0x4, VT_DISPATCH, propVal);
  75. }
  77. CMoRectangle CMap1::GetExtent()
  78. {
  79. LPDISPATCH pDispatch;
  80. GetProperty(0x5, VT_DISPATCH, (void*)&pDispatch);
  81. return CMoRectangle(pDispatch);
  82. }
  84. void CMap1::SetExtent(LPDISPATCH propVal)
  85. {
  86. SetProperty(0x5, VT_DISPATCH, propVal);
  87. }
  89. CMoRectangle CMap1::GetFullExtent()
  90. {
  91. LPDISPATCH pDispatch;
  92. GetProperty(0x6, VT_DISPATCH, (void*)&pDispatch);
  93. return CMoRectangle(pDispatch);
  94. }
  96. void CMap1::SetFullExtent(LPDISPATCH propVal)
  97. {
  98. SetProperty(0x6, VT_DISPATCH, propVal);
  99. }
  101. OLE_COLOR CMap1::GetBackColor()
  102. {
  103. OLE_COLOR result;
  104. GetProperty(DISPID_BACKCOLOR, VT_I4, (void*)&result);
  105. return result;
  106. }
  108. void CMap1::SetBackColor(OLE_COLOR propVal)
  109. {
  110. SetProperty(DISPID_BACKCOLOR, VT_I4, propVal);
  111. }
  113. short CMap1::GetBorderStyle()
  114. {
  115. short result;
  116. GetProperty(DISPID_BORDERSTYLE, VT_I2, (void*)&result);
  117. return result;
  118. }
  120. void CMap1::SetBorderStyle(short propVal)
  121. {
  122. SetProperty(DISPID_BORDERSTYLE, VT_I2, propVal);
  123. }
  125. BOOL CMap1::GetScrollBars()
  126. {
  127. BOOL result;
  128. GetProperty(0x2, VT_BOOL, (void*)&result);
  129. return result;
  130. }
  132. void CMap1::SetScrollBars(BOOL propVal)
  133. {
  134. SetProperty(0x2, VT_BOOL, propVal);
  135. }
  137. long CMap1::GetCancelAction()
  138. {
  139. long result;
  140. GetProperty(0x8, VT_I4, (void*)&result);
  141. return result;
  142. }
  144. void CMap1::SetCancelAction(long propVal)
  145. {
  146. SetProperty(0x8, VT_I4, propVal);
  147. }
  149. CMoTrackingLayer CMap1::GetTrackingLayer()
  150. {
  151. LPDISPATCH pDispatch;
  152. GetProperty(0x9, VT_DISPATCH, (void*)&pDispatch);
  153. return CMoTrackingLayer(pDispatch);
  154. }
  156. void CMap1::SetTrackingLayer(LPDISPATCH propVal)
  157. {
  158. SetProperty(0x9, VT_DISPATCH, propVal);
  159. }
  161. long CMap1::GetRefreshCount()
  162. {
  163. long result;
  164. GetProperty(0xa, VT_I4, (void*)&result);
  165. return result;
  166. }
  168. void CMap1::SetRefreshCount(long propVal)
  169. {
  170. SetProperty(0xa, VT_I4, propVal);
  171. }
  173. BOOL CMap1::GetEnabled()
  174. {
  175. BOOL result;
  176. GetProperty(DISPID_ENABLED, VT_BOOL, (void*)&result);
  177. return result;
  178. }
  180. void CMap1::SetEnabled(BOOL propVal)
  181. {
  182. SetProperty(DISPID_ENABLED, VT_BOOL, propVal);
  183. }
  185. OLE_HANDLE CMap1::GetHWnd()
  186. {
  187. OLE_HANDLE result;
  188. GetProperty(DISPID_HWND, VT_I4, (void*)&result);
  189. return result;
  190. }
  192. void CMap1::SetHWnd(OLE_HANDLE propVal)
  193. {
  194. SetProperty(DISPID_HWND, VT_I4, propVal);
  195. }
  197. short CMap1::GetAppearance()
  198. {
  199. short result;
  200. GetProperty(DISPID_APPEARANCE, VT_I4, (void*)&result);
  201. return result;
  202. }
  204. void CMap1::SetAppearance(short propVal)
  205. {
  206. SetProperty(DISPID_APPEARANCE, VT_I4, propVal);
  207. }
  209. double CMap1::GetMinWidth()
  210. {
  211. double result;
  212. GetProperty(0x1, VT_R8, (void*)&result);
  213. return result;
  214. }
  216. void CMap1::SetMinWidth(double propVal)
  217. {
  218. SetProperty(0x1, VT_R8, propVal);
  219. }
  221. long CMap1::GetMousePointer()
  222. {
  223. long result;
  224. GetProperty(0xb, VT_I4, (void*)&result);
  225. return result;
  226. }
  228. void CMap1::SetMousePointer(long propVal)
  229. {
  230. SetProperty(0xb, VT_I4, propVal);
  231. }
  233. BOOL CMap1::GetFullRedrawOnPan()
  234. {
  235. BOOL result;
  236. GetProperty(0x3, VT_BOOL, (void*)&result);
  237. return result;
  238. }
  240. void CMap1::SetFullRedrawOnPan(BOOL propVal)
  241. {
  242. SetProperty(0x3, VT_BOOL, propVal);
  243. }
  245. VARIANT CMap1::GetCoordinateSystem()
  246. {
  247. VARIANT result;
  248. GetProperty(0xc, VT_VARIANT, (void*)&result);
  249. return result;
  250. }
  252. void CMap1::SetCoordinateSystem(const VARIANT& propVal)
  253. {
  254. SetProperty(0xc, VT_VARIANT, &propVal);
  255. }
  257. long CMap1::GetMaxFileBuffer()
  258. {
  259. long result;
  260. GetProperty(0xd, VT_I4, (void*)&result);
  261. return result;
  262. }
  264. void CMap1::SetMaxFileBuffer(long propVal)
  265. {
  266. SetProperty(0xd, VT_I4, propVal);
  267. }
  269. long CMap1::GetWindowMode()
  270. {
  271. long result;
  272. GetProperty(0xe, VT_I4, (void*)&result);
  273. return result;
  274. }
  276. void CMap1::SetWindowMode(long propVal)
  277. {
  278. SetProperty(0xe, VT_I4, propVal);
  279. }
  281. double CMap1::GetRotationAngle()
  282. {
  283. double result;
  284. GetProperty(0xf, VT_R8, (void*)&result);
  285. return result;
  286. }
  288. void CMap1::SetRotationAngle(double propVal)
  289. {
  290. SetProperty(0xf, VT_R8, propVal);
  291. }
  293. LPDISPATCH CMap1::GetVisibleRegion()
  294. {
  295. LPDISPATCH result;
  296. GetProperty(0x10, VT_DISPATCH, (void*)&result);
  297. return result;
  298. }
  300. void CMap1::SetVisibleRegion(LPDISPATCH propVal)
  301. {
  302. SetProperty(0x10, VT_DISPATCH, propVal);
  303. }
  305. /////////////////////////////////////////////////////////////////////////////
  306. // CMap1 operations
  308. void CMap1::Pan()
  309. {
  310. InvokeHelper(0x11, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  311. }
  313. CMoPoint CMap1::ToMapPoint(float X, float Y)
  314. {
  315. LPDISPATCH pDispatch;
  316. static BYTE parms[] =
  317. VTS_R4 VTS_R4;
  318. InvokeHelper(0x12, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
  319. X, Y);
  320. return CMoPoint(pDispatch);
  321. }
  323. void CMap1::FlashShape(LPDISPATCH shape, short nTimes)
  324. {
  325. static BYTE parms[] =
  326. VTS_DISPATCH VTS_I2;
  327. InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  328.  shape, nTimes);
  329. }
  331. void CMap1::Refresh()
  332. {
  333. InvokeHelper(DISPID_REFRESH, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  334. }
  336. void CMap1::DrawShape(LPDISPATCH shape, LPDISPATCH Symbol)
  337. {
  338. static BYTE parms[] =
  339. VTS_DISPATCH VTS_DISPATCH;
  340. InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  341.  shape, Symbol);
  342. }
  344. void CMap1::DrawText(LPCTSTR text, LPDISPATCH shape, LPDISPATCH Symbol)
  345. {
  346. static BYTE parms[] =
  347. VTS_BSTR VTS_DISPATCH VTS_DISPATCH;
  348. InvokeHelper(0x15, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  349.  text, shape, Symbol);
  350. }
  352. CMoEllipse CMap1::TrackCircle()
  353. {
  354. LPDISPATCH pDispatch;
  355. InvokeHelper(0x16, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
  356. return CMoEllipse(pDispatch);
  357. }
  359. CMoLine CMap1::TrackLine()
  360. {
  361. LPDISPATCH pDispatch;
  362. InvokeHelper(0x17, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
  363. return CMoLine(pDispatch);
  364. }
  366. CMoRectangle CMap1::TrackRectangle()
  367. {
  368. LPDISPATCH pDispatch;
  369. InvokeHelper(0x18, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
  370. return CMoRectangle(pDispatch);
  371. }
  373. void CMap1::FromMapPoint(LPDISPATCH Point, float* X, float* Y)
  374. {
  375. static BYTE parms[] =
  376. VTS_DISPATCH VTS_PR4 VTS_PR4;
  377. InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  378.  Point, X, Y);
  379. }
  381. double CMap1::ToMapDistance(float distance)
  382. {
  383. double result;
  384. static BYTE parms[] =
  385. VTS_R4;
  386. InvokeHelper(0x1a, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
  387. distance);
  388. return result;
  389. }
  391. float CMap1::FromMapDistance(double distance)
  392. {
  393. float result;
  394. static BYTE parms[] =
  395. VTS_R8;
  396. InvokeHelper(0x1b, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
  397. distance);
  398. return result;
  399. }
  401. CMoPolygon CMap1::TrackPolygon()
  402. {
  403. LPDISPATCH pDispatch;
  404. InvokeHelper(0x1c, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
  405. return CMoPolygon(pDispatch);
  406. }
  408. void CMap1::OutputMap(long hDC)
  409. {
  410. static BYTE parms[] =
  411. VTS_I4;
  412. InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  413.  hDC);
  414. }
  416. void CMap1::PrintMap(LPCTSTR docName, LPCTSTR outputFile, BOOL landscapeOrientation)
  417. {
  418. static BYTE parms[] =
  419. VTS_BSTR VTS_BSTR VTS_BOOL;
  420. InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  421.  docName, outputFile, landscapeOrientation);
  422. }
  424. void CMap1::ExportMap(long exportType, LPCTSTR outputFile, double scaleFactor)
  425. {
  426. static BYTE parms[] =
  427. VTS_I4 VTS_BSTR VTS_R8;
  428. InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  429.  exportType, outputFile, scaleFactor);
  430. }
  432. void CMap1::CopyMap(double scaleFactor)
  433. {
  434. static BYTE parms[] =
  435. VTS_R8;
  436. InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  437.  scaleFactor);
  438. }
  440. void CMap1::CenterAt(double X, double Y)
  441. {
  442. static BYTE parms[] =
  443. VTS_R8 VTS_R8;
  444. InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  445.  X, Y);
  446. }
  448. void CMap1::RefreshLayer(short index, const VARIANT& rect)
  449. {
  450. static BYTE parms[] =
  451. VTS_I2 VTS_VARIANT;
  452. InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  453.  index, &rect);
  454. }
  456. void CMap1::ExportMap2(long exportType, LPCTSTR outputFile, double scaleFactor, const VARIANT& useSourceDepth)
  457. {
  458. static BYTE parms[] =
  459. VTS_I4 VTS_BSTR VTS_R8 VTS_VARIANT;
  460. InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  461.  exportType, outputFile, scaleFactor, &useSourceDepth);
  462. }
  464. void CMap1::OutputMap2(long hDC, long X, long Y, long Width, long Height, const VARIANT& DrawFlags)
  465. {
  466. static BYTE parms[] =
  467. VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_VARIANT;
  468. InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  469.  hDC, X, Y, Width, Height, &DrawFlags);
  470. }
  472. void CMap1::RefreshRect(LPDISPATCH rect)
  473. {
  474. static BYTE parms[] =
  475. VTS_DISPATCH;
  476. InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  477.  rect);
  478. }
  480. void CMap1::EnableTIFFLZW(LPCTSTR licenseCode)
  481. {
  482. static BYTE parms[] =
  483. VTS_BSTR;
  484. InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  485.  licenseCode);
  486. }
  488. void CMap1::EnableGIF(LPCTSTR licenseCode)
  489. {
  490. static BYTE parms[] =
  491. VTS_BSTR;
  492. InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  493.  licenseCode);
  494. }
  496. void CMap1::AboutBox()
  497. {
  498. InvokeHelper(0xfffffdd8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  499. }