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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > GIS编程 > 查看源码
Mapx.cpp
资源名称：Mapx开发实例（vc++ gps跟踪）.zip　[点击查看]
上传用户：hzwailv
上传日期：2010-01-09
资源大小：405k
文件大小：145k
源码类别：

GIS编程

开发平台：

Visual C++

Mapx.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "mapx.h"
  4. /////////////////////////////////////////////////////////////////////////////
  5. // CMapX
  7. IMPLEMENT_DYNCREATE(CMapX, CWnd)
  9. /////////////////////////////////////////////////////////////////////////////
  10. // CMapX properties
  12. CString CMapX::GetDataSetGeoField()
  13. {
  14. CString result;
  15. GetProperty(0x1, VT_BSTR, (void*)&result);
  16. return result;
  17. }
  19. void CMapX::SetDataSetGeoField(LPCTSTR propVal)
  20. {
  21. SetProperty(0x1, VT_BSTR, propVal);
  22. }
  24. CString CMapX::GetVersion()
  25. {
  26. CString result;
  27. GetProperty(0x2, VT_BSTR, (void*)&result);
  28. return result;
  29. }
  31. OLE_HANDLE CMapX::GetHWnd()
  32. {
  33. OLE_HANDLE result;
  34. GetProperty(DISPID_HWND, VT_I4, (void*)&result);
  35. return result;
  36. }
  38. CMapXAnnotations CMapX::GetAnnotations()
  39. {
  40. LPDISPATCH result;
  41. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  42. return CMapXAnnotations(result);
  43. }
  45. CMapXLayers CMapX::GetLayers()
  46. {
  47. LPDISPATCH result;
  48. GetProperty(0x5, VT_DISPATCH, (void*)&result);
  49. return CMapXLayers(result);
  50. }
  52. BOOL CMapX::GetAutoRedraw()
  53. {
  54. BOOL result;
  55. GetProperty(0x6, VT_BOOL, (void*)&result);
  56. return result;
  57. }
  59. void CMapX::SetAutoRedraw(BOOL propVal)
  60. {
  61. SetProperty(0x6, VT_BOOL, propVal);
  62. }
  64. double CMapX::GetZoom()
  65. {
  66. double result;
  67. GetProperty(0x7, VT_R8, (void*)&result);
  68. return result;
  69. }
  71. void CMapX::SetZoom(double propVal)
  72. {
  73. SetProperty(0x7, VT_R8, propVal);
  74. }
  76. double CMapX::GetCenterX()
  77. {
  78. double result;
  79. GetProperty(0x8, VT_R8, (void*)&result);
  80. return result;
  81. }
  83. void CMapX::SetCenterX(double propVal)
  84. {
  85. SetProperty(0x8, VT_R8, propVal);
  86. }
  88. double CMapX::GetCenterY()
  89. {
  90. double result;
  91. GetProperty(0x9, VT_R8, (void*)&result);
  92. return result;
  93. }
  95. void CMapX::SetCenterY(double propVal)
  96. {
  97. SetProperty(0x9, VT_R8, propVal);
  98. }
  100. CString CMapX::GetGeoSet()
  101. {
  102. CString result;
  103. GetProperty(0xa, VT_BSTR, (void*)&result);
  104. return result;
  105. }
  107. void CMapX::SetGeoSet(LPCTSTR propVal)
  108. {
  109. SetProperty(0xa, VT_BSTR, propVal);
  110. }
  112. double CMapX::GetGeoSetWidth()
  113. {
  114. double result;
  115. GetProperty(0xb, VT_R8, (void*)&result);
  116. return result;
  117. }
  119. double CMapX::GetMapPaperHeight()
  120. {
  121. double result;
  122. GetProperty(0xc, VT_R8, (void*)&result);
  123. return result;
  124. }
  126. double CMapX::GetMapPaperWidth()
  127. {
  128. double result;
  129. GetProperty(0xd, VT_R8, (void*)&result);
  130. return result;
  131. }
  133. short CMapX::GetMaxSearchTime()
  134. {
  135. short result;
  136. GetProperty(0xe, VT_I2, (void*)&result);
  137. return result;
  138. }
  140. void CMapX::SetMaxSearchTime(short propVal)
  141. {
  142. SetProperty(0xe, VT_I2, propVal);
  143. }
  145. long CMapX::GetPaperUnit()
  146. {
  147. long result;
  148. GetProperty(0xf, VT_I4, (void*)&result);
  149. return result;
  150. }
  152. void CMapX::SetPaperUnit(long propVal)
  153. {
  154. SetProperty(0xf, VT_I4, propVal);
  155. }
  157. BOOL CMapX::GetPreferCompactLegends()
  158. {
  159. BOOL result;
  160. GetProperty(0x10, VT_BOOL, (void*)&result);
  161. return result;
  162. }
  164. void CMapX::SetPreferCompactLegends(BOOL propVal)
  165. {
  166. SetProperty(0x10, VT_BOOL, propVal);
  167. }
  169. CMapXStyle CMapX::GetDefaultStyle()
  170. {
  171. LPDISPATCH result;
  172. GetProperty(0x11, VT_DISPATCH, (void*)&result);
  173. return CMapXStyle(result);
  174. }
  176. void CMapX::SetDefaultStyle(LPDISPATCH propVal)
  177. {
  178. SetProperty(0x11, VT_DISPATCH, propVal);
  179. }
  181. CString CMapX::GetGeoDictionary()
  182. {
  183. CString result;
  184. GetProperty(0x12, VT_BSTR, (void*)&result);
  185. return result;
  186. }
  188. void CMapX::SetGeoDictionary(LPCTSTR propVal)
  189. {
  190. SetProperty(0x12, VT_BSTR, propVal);
  191. }
  193. long CMapX::GetDataSetTheme()
  194. {
  195. long result;
  196. GetProperty(0x13, VT_I4, (void*)&result);
  197. return result;
  198. }
  200. void CMapX::SetDataSetTheme(long propVal)
  201. {
  202. SetProperty(0x13, VT_I4, propVal);
  203. }
  205. long CMapX::GetCurrentTool()
  206. {
  207. long result;
  208. GetProperty(0x14, VT_I4, (void*)&result);
  209. return result;
  210. }
  212. void CMapX::SetCurrentTool(long propVal)
  213. {
  214. SetProperty(0x14, VT_I4, propVal);
  215. }
  217. long CMapX::GetMousePointer()
  218. {
  219. long result;
  220. GetProperty(0x15, VT_I4, (void*)&result);
  221. return result;
  222. }
  224. void CMapX::SetMousePointer(long propVal)
  225. {
  226. SetProperty(0x15, VT_I4, propVal);
  227. }
  229. CMapXDatasets CMapX::GetDatasets()
  230. {
  231. LPDISPATCH result;
  232. GetProperty(0x16, VT_DISPATCH, (void*)&result);
  233. return CMapXDatasets(result);
  234. }
  236. CMapXTitle CMapX::GetTitle()
  237. {
  238. LPDISPATCH result;
  239. GetProperty(0x17, VT_DISPATCH, (void*)&result);
  240. return CMapXTitle(result);
  241. }
  243. CString CMapX::GetTitleText()
  244. {
  245. CString result;
  246. GetProperty(0x18, VT_BSTR, (void*)&result);
  247. return result;
  248. }
  250. void CMapX::SetTitleText(LPCTSTR propVal)
  251. {
  252. SetProperty(0x18, VT_BSTR, propVal);
  253. }
  255. long CMapX::GetMapUnit()
  256. {
  257. long result;
  258. GetProperty(0x19, VT_I4, (void*)&result);
  259. return result;
  260. }
  262. void CMapX::SetMapUnit(long propVal)
  263. {
  264. SetProperty(0x19, VT_I4, propVal);
  265. }
  267. double CMapX::GetRotation()
  268. {
  269. double result;
  270. GetProperty(0x1a, VT_R8, (void*)&result);
  271. return result;
  272. }
  274. void CMapX::SetRotation(double propVal)
  275. {
  276. SetProperty(0x1a, VT_R8, propVal);
  277. }
  279. CMapXGeosets CMapX::GetGeosets()
  280. {
  281. LPDISPATCH result;
  282. GetProperty(0x1b, VT_DISPATCH, (void*)&result);
  283. return CMapXGeosets(result);
  284. }
  286. long CMapX::GetAreaUnit()
  287. {
  288. long result;
  289. GetProperty(0x1c, VT_I4, (void*)&result);
  290. return result;
  291. }
  293. void CMapX::SetAreaUnit(long propVal)
  294. {
  295. SetProperty(0x1c, VT_I4, propVal);
  296. }
  298. CMapXRectangle CMapX::GetBounds()
  299. {
  300. LPDISPATCH result;
  301. GetProperty(0x1d, VT_DISPATCH, (void*)&result);
  302. return CMapXRectangle(result);
  303. }
  305. void CMapX::SetBounds(LPDISPATCH propVal)
  306. {
  307. SetProperty(0x1d, VT_DISPATCH, propVal);
  308. }
  310. CMapXCoordSys CMapX::GetDisplayCoordSys()
  311. {
  312. LPDISPATCH result;
  313. GetProperty(0x1e, VT_DISPATCH, (void*)&result);
  314. return CMapXCoordSys(result);
  315. }
  317. void CMapX::SetDisplayCoordSys(LPDISPATCH propVal)
  318. {
  319. SetProperty(0x1e, VT_DISPATCH, propVal);
  320. }
  322. CMapXCoordSys CMapX::GetNumericCoordSys()
  323. {
  324. LPDISPATCH result;
  325. GetProperty(0x1f, VT_DISPATCH, (void*)&result);
  326. return CMapXCoordSys(result);
  327. }
  329. void CMapX::SetNumericCoordSys(LPDISPATCH propVal)
  330. {
  331. SetProperty(0x1f, VT_DISPATCH, propVal);
  332. }
  334. BOOL CMapX::GetExportSelection()
  335. {
  336. BOOL result;
  337. GetProperty(0x20, VT_BOOL, (void*)&result);
  338. return result;
  339. }
  341. void CMapX::SetExportSelection(BOOL propVal)
  342. {
  343. SetProperty(0x20, VT_BOOL, propVal);
  344. }
  346. CMapXStyle CMapX::GetSelectionStyle()
  347. {
  348. LPDISPATCH result;
  349. GetProperty(0x21, VT_DISPATCH, (void*)&result);
  350. return CMapXStyle(result);
  351. }
  353. void CMapX::SetSelectionStyle(LPDISPATCH propVal)
  354. {
  355. SetProperty(0x21, VT_DISPATCH, propVal);
  356. }
  358. CMapXFeatureFactory CMapX::GetFeatureFactory()
  359. {
  360. LPDISPATCH result;
  361. GetProperty(0x31, VT_DISPATCH, (void*)&result);
  362. return CMapXFeatureFactory(result);
  363. }
  365. long CMapX::GetDefaultConversionResolution()
  366. {
  367. long result;
  368. GetProperty(0x32, VT_I4, (void*)&result);
  369. return result;
  370. }
  372. void CMapX::SetDefaultConversionResolution(long propVal)
  373. {
  374. SetProperty(0x32, VT_I4, propVal);
  375. }
  377. OLE_COLOR CMapX::GetBackColor()
  378. {
  379. OLE_COLOR result;
  380. GetProperty(DISPID_BACKCOLOR, VT_I4, (void*)&result);
  381. return result;
  382. }
  384. void CMapX::SetBackColor(OLE_COLOR propVal)
  385. {
  386. SetProperty(DISPID_BACKCOLOR, VT_I4, propVal);
  387. }
  389. long CMapX::GetMousewheelSupport()
  390. {
  391. long result;
  392. GetProperty(0x33, VT_I4, (void*)&result);
  393. return result;
  394. }
  396. void CMapX::SetMousewheelSupport(long propVal)
  397. {
  398. SetProperty(0x33, VT_I4, propVal);
  399. }
  401. BOOL CMapX::GetMatchNumericFields()
  402. {
  403. BOOL result;
  404. GetProperty(0x34, VT_BOOL, (void*)&result);
  405. return result;
  406. }
  408. void CMapX::SetMatchNumericFields(BOOL propVal)
  409. {
  410. SetProperty(0x34, VT_BOOL, propVal);
  411. }
  413. double CMapX::GetMapScreenWidth()
  414. {
  415. double result;
  416. GetProperty(0x35, VT_R8, (void*)&result);
  417. return result;
  418. }
  420. double CMapX::GetMapScreenHeight()
  421. {
  422. double result;
  423. GetProperty(0x36, VT_R8, (void*)&result);
  424. return result;
  425. }
  427. long CMapX::GetRedrawInterval()
  428. {
  429.   long result;
  430. GetProperty(0x37, VT_I4, (void*)&result);
  431. return result;
  432. }
  434. void CMapX::SetRedrawInterval(long propVal)
  435. {
  436. SetProperty(0x37, VT_I4, propVal);
  437. }
  439. CString CMapX::GetSearchPath()
  440. {
  441. CString result;
  442. GetProperty(0x38, VT_BSTR, (void*)&result);
  443. return result;
  444. }
  446. void CMapX::SetSearchPath(LPCTSTR propVal)
  447. {
  448. SetProperty(0x38, VT_BSTR, propVal);
  449. }
  451. short CMapX::GetMatchThreshold()
  452. {
  453.   short result;
  454. GetProperty(0x39, VT_I2, (void*)&result);
  455. return result;
  456. }
  458. void CMapX::SetMatchThreshold(short propVal)
  459. {
  460. SetProperty(0x39, VT_I2, propVal);
  461. }
  463. BOOL CMapX::GetWaitCursorEnabled()
  464. {
  465.   BOOL result;
  466. GetProperty(0x3a, VT_BOOL, (void*)&result);
  467. return result;
  468. }
  470. void CMapX::SetWaitCursorEnabled(BOOL propVal)
  471. {
  472. SetProperty(0x3a, VT_BOOL, propVal);
  473. }
  475. BOOL CMapX::GetPanAnimationLayer()
  476. {
  477.   BOOL result;
  478. GetProperty(0x3c, VT_BOOL, (void*)&result);
  479. return result;
  480. }
  482. void CMapX::SetPanAnimationLayer(BOOL propVal)
  483. {
  484. SetProperty(0x3c, VT_BOOL, propVal);
  485. }
  487. long CMapX::GetInfotipPopupDelay()
  488. {
  489. long result;
  490. GetProperty(0x3d, VT_I4, (void*)&result);
  491. return result;
  492. }
  494. void CMapX::SetInfotipPopupDelay(long propVal)
  495. {
  496. SetProperty(0x3d, VT_I4, propVal);
  497. }
  499. CString CMapX::GetMouseIcon()
  500. {
  501. CString result;
  502. GetProperty(0x3e, VT_BSTR, (void*)&result);
  503. return result;
  504. }
  506. void CMapX::SetMouseIcon(LPCTSTR propVal)
  507. {
  508. SetProperty(0x3e, VT_BSTR, propVal);
  509. }
  511. BOOL CMapX::GetInfotipSupport()
  512. {
  513.   BOOL result;
  514. GetProperty(0x3f, VT_BOOL, (void*)&result);
  515. return result;
  516. }
  518. void CMapX::SetInfotipSupport(BOOL propVal)
  519. {
  520. SetProperty(0x3f, VT_BOOL, propVal);
  521. }
  523. short CMapX::GetFeatureEditMode()
  524. {
  525. short result;
  526. GetProperty(0x41, VT_I2, (void*)&result);
  527. return result;
  528. }
  530. void CMapX::SetFeatureEditMode(short propVal)
  531. {
  532. SetProperty(0x41, VT_I2, propVal);
  533. }
  535. long CMapX::GetCheckEscapeKeyInterval()
  536. {
  537. long result;
  538. GetProperty(0x43, VT_I4, (void*)&result);
  539. return result;
  540. }
  542. void CMapX::SetCheckEscapeKeyInterval(long propVal)
  543. {
  544. SetProperty(0x43, VT_I4, propVal);
  545. }
  547. /////////////////////////////////////////////////////////////////////////////
  548. // CMapX operations
  550. void CMapX::ConvertCoord(float* ScreenX, float* ScreenY, double* MapX, double* MapY, short Direction)
  551. {
  552. static BYTE parms[] =
  553. VTS_PR4 VTS_PR4 VTS_PR8 VTS_PR8 VTS_I2;
  554. InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  555.  ScreenX, ScreenY, MapX, MapY, Direction);
  556. }
  558. void CMapX::ZoomTo(double Zoom, double X, double Y)
  559. {
  560. static BYTE parms[] =
  561. VTS_R8 VTS_R8 VTS_R8;
  562. InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  563.  Zoom, X, Y);
  564. }
  566. void CMapX::CreateCustomTool(
  567. short ToolNumber, 
  568. short Type, 
  569. const VARIANT& Cursor, 
  570. const VARIANT& ShiftCursor, 
  571. const VARIANT& CtrlCursor, 
  572. const VARIANT& bInfoTips)
  573. {
  574. static BYTE parms[] =
  575. VTS_I2 VTS_I2 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  576. InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  577.  ToolNumber, Type, &Cursor, &CtrlCursor, &ShiftCursor, &bInfoTips);
  578. }
  580. double CMapX::Distance(double X1, double Y1, double X2, double Y2)
  581. {
  582. double result;
  583. static BYTE parms[] =
  584. VTS_R8 VTS_R8 VTS_R8 VTS_R8;
  585. InvokeHelper(0x25, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
  586. X1, Y1, X2, Y2);
  587. return result;
  588. }
  590. void CMapX::Refresh()
  591. {
  592. InvokeHelper(DISPID_REFRESH, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  593. }
  595. void CMapX::PrintMap(long hDC, long X, long Y, long W, long H)
  596. {
  597. static BYTE parms[] =
  598. VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  599. InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  600.  hDC, X, Y, W, H);
  601. }
  603. void CMapX::ExportMap(LPCTSTR Destination, short Format, const VARIANT& Width, const VARIANT& Height)
  604. {
  605. static BYTE parms[] =
  606. VTS_BSTR VTS_I2 VTS_VARIANT VTS_VARIANT;
  607. InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  608.  Destination, Format, &Width, &Height);
  609. }
  611. void CMapX::PropertyPage()
  612. {
  613. InvokeHelper(0x28, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  614. }
  616. void CMapX::ConvertCoordV(VARIANT* ScreenX, VARIANT* ScreenY, VARIANT* MapX, VARIANT* MapY, short Direction)
  617. {
  618. static BYTE parms[] =
  619. VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_I2;
  620. InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  621.  ScreenX, ScreenY, MapX, MapY, Direction);
  622. }
  624. void CMapX::SetSize(long Width, long Height)
  625. {
  626. static BYTE parms[] =
  627. VTS_I4 VTS_I4;
  628. InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  629.  Width, Height);
  630. }
  632. BOOL CMapX::IsPointVisible(double X, double Y)
  633. {
  634. BOOL result;
  635. static BYTE parms[] =
  636. VTS_R8 VTS_R8;
  637. InvokeHelper(0x2b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  638. X, Y);
  639. return result;
  640. }
  642. BOOL CMapX::ClipLine(double* X1, double* Y1, double* X2, double* Y2)
  643. {
  644. BOOL result;
  645. static BYTE parms[] =
  646. VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8;
  647. InvokeHelper(0x2c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  648. X1, Y1, X2, Y2);
  649. return result;
  650. }
  652. BOOL CMapX::ClipLineV(VARIANT* X1, VARIANT* Y1, VARIANT* X2, VARIANT* Y2)
  653. {
  654. BOOL result;
  655. static BYTE parms[] =
  656. VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
  657. InvokeHelper(0x2d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  658. X1, Y1, X2, Y2);
  659. return result;
  660. }
  662. void CMapX::AboutBox()
  663. {
  664. InvokeHelper(0xfffffdd8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  665. }
  667. void CMapX::SaveMapAsGeoset(LPCTSTR Name, LPCTSTR Filespec)
  668. {
  669. static BYTE parms[] =
  670. VTS_BSTR VTS_BSTR;
  671. InvokeHelper(0x2f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  672. Name, Filespec);
  673. }
  675. LPDISPATCH CMapX::GetDispatch(BOOL bAddRef)
  676. {
  677. LPUNKNOWN pUnk = GetControlUnknown();
  678. LPDISPATCH pDispatch;
  680. if ((pUnk != NULL) && SUCCEEDED(pUnk->QueryInterface(IID_IDispatch, (LPVOID*)&pDispatch))) {
  681. ASSERT(pDispatch != NULL);
  682. if (!bAddRef) {
  683. pDispatch->Release();
  684. }
  685. return pDispatch;
  686. }
  687. return NULL;
  688. }
  690. void CMapX::Pan(float ScreenX, float ScreenY)
  691. {
  692. static BYTE parms[] =
  693. VTS_R4 VTS_R4;
  694. InvokeHelper(0x40, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  695.  ScreenX, ScreenY);
  696. }
  698. /////////////////////////////////////////////////////////////////////////////
  699. // CMapXDatasets properties
  701. LPENUMVARIANT CMapXDatasets::GetEnumerator()
  702. {
  703. LPENUMVARIANT pEnumVariant = 0;
  704. LPUNKNOWN pUnknown = 0;
  705. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  706. if(pUnknown)
  707. {
  708. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  709. pUnknown->Release();
  710. }
  711. return pEnumVariant;
  712. }
  714. long CMapXDatasets::GetCount()
  715. {
  716. long result;
  717. GetProperty(0x1, VT_I4, (void*)&result);
  718. return result;
  719. }
  721. BOOL CMapXDatasets::GetBuildSourceRows()
  722. {
  723.   BOOL result;
  724. GetProperty(0x7, VT_BOOL, &result);
  725. return result;
  726. }
  728. void CMapXDatasets::SetBuildSourceRows(BOOL b)
  729. {
  730. SetProperty(0x7, VT_BOOL, b);
  731. }
  733. /////////////////////////////////////////////////////////////////////////////
  734. // CMapXDatasets operations
  736. CMapXDataset CMapXDatasets::Add(long Type, const VARIANT& SourceData, const VARIANT& Name, const VARIANT& GeoField, const VARIANT& SecondaryGeoField, const VARIANT& BindLayer, const VARIANT& Fields, const VARIANT& Dynamic)
  737. {
  738. LPDISPATCH result;
  739. static BYTE parms[] =
  740. VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  741. InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  742. Type, &SourceData, &Name, &GeoField, &SecondaryGeoField, &BindLayer, &Fields, &Dynamic);
  743. return CMapXDataset(result);
  744. }
  746. CMapXDataset CMapXDatasets::Item(const VARIANT& Index)
  747. {
  748. LPDISPATCH result;
  749. static BYTE parms[] =
  750. VTS_VARIANT;
  751. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  752. &Index);
  753. return CMapXDataset(result);
  754. }
  756. void CMapXDatasets::Remove(const VARIANT& Index)
  757. {
  758. static BYTE parms[] =
  759. VTS_VARIANT;
  760. InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  761.  &Index);
  762. }
  764. CMapXDataset CMapXDatasets::Restore(LPCTSTR Name, const VARIANT& SourceData)
  765. {
  766. LPDISPATCH result;
  767. static BYTE parms[] =
  768. VTS_BSTR VTS_VARIANT;
  769. InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  770. Name, &SourceData);
  771. return CMapXDataset(result);
  772. }
  774. void CMapXDatasets::RemoveAll()
  775. {
  776. InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  777. }
  779. /////////////////////////////////////////////////////////////////////////////
  780. // CMapXLayers properties
  782. LPENUMVARIANT CMapXLayers::GetEnumerator()
  783. {
  784. LPENUMVARIANT pEnumVariant = 0;
  785. LPUNKNOWN pUnknown = 0;
  786. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  787. if(pUnknown)
  788. {
  789. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  790. pUnknown->Release();
  791. }
  792. return pEnumVariant;
  793. }
  795. long CMapXLayers::GetCount()
  796. {
  797. long result;
  798. GetProperty(0x1, VT_I4, (void*)&result);
  799. return result;
  800. }
  802. /////////////////////////////////////////////////////////////////////////////
  803. // CMapXLayers operations
  805. void CMapXLayers::ClearSelection()
  806. {
  807. InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  808. }
  810. BOOL CMapXLayers::Move(short From, short To)
  811. {
  812. BOOL result;
  813. static BYTE parms[] =
  814. VTS_I2 VTS_I2;
  815. InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  816. From, To);
  817. return result;
  818. }
  820. CMapXLayer CMapXLayers::Add(const VARIANT& LayerInfo, const VARIANT& Position)
  821. {
  822. LPDISPATCH result;
  823. static BYTE parms[] =
  824. VTS_VARIANT VTS_VARIANT;
  825. InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  826. &LayerInfo, &Position);
  827. return CMapXLayer(result);
  828. }
  830. void CMapXLayers::AddGeoSetLayers(LPCTSTR GeoSetName)
  831. {
  832. static BYTE parms[] =
  833. VTS_BSTR;
  834. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  835.  GeoSetName);
  836. }
  838. CMapXLayer CMapXLayers::Item(const VARIANT& Index)
  839. {
  840. LPDISPATCH result;
  841. static BYTE parms[] =
  842. VTS_VARIANT;
  843. InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  844. &Index);
  845. return CMapXLayer(result);
  846. }
  848. void CMapXLayers::Remove(const VARIANT& Index)
  849. {
  850. static BYTE parms[] =
  851. VTS_VARIANT;
  852. InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  853.  &Index);
  854. }
  856. CMapXLayer CMapXLayers::AddUserDrawLayer(LPCTSTR Name, short Position)
  857. {
  858. LPDISPATCH result;
  859. static BYTE parms[] =
  860. VTS_BSTR VTS_I2;
  861. InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  862. Name, Position);
  863. return CMapXLayer(result);
  864. }
  866. CMapXLayer CMapXLayers::GetAnimationLayer()
  867. {
  868. LPDISPATCH result;
  869. GetProperty(0x9, VT_DISPATCH, (void*)&result);
  870. return CMapXLayer(result);
  871. }
  873. void CMapXLayers::SetAnimationLayer(LPDISPATCH propVal)
  874. {
  875. SetProperty(0x9, VT_DISPATCH, propVal);
  876. }
  878. CMapXRectangle CMapXLayers::GetBounds()
  879. {
  880. LPDISPATCH result;
  881. GetProperty(0xc, VT_DISPATCH, (void*)&result);
  882. return CMapXRectangle(result);
  883. }
  885. CMapXLayer CMapXLayers::CreateLayer(LPCTSTR Name, const VARIANT& Filespec, const VARIANT& Position, const VARIANT& KeyLength, const VARIANT& CoordSys)
  886. {
  887. LPDISPATCH result;
  888. static BYTE parms[] =
  889. VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  890. InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  891. Name, &Filespec, &Position, &KeyLength, &CoordSys);
  892. return CMapXLayer(result);
  893. }
  895. BOOL CMapXLayers::LayersDlg(const VARIANT& HelpFile, const VARIANT& HelpID)
  896. {
  897. BOOL result;
  898. static BYTE parms[] =
  899. VTS_VARIANT VTS_VARIANT;
  900. InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  901. &HelpFile, &HelpID);
  902. return result;
  903. }
  905. CMapXLayer CMapXLayers::AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query, const VARIANT& Position, const VARIANT& Options)
  906. {
  907. LPDISPATCH result;
  908. static BYTE parms[] =
  909. VTS_BSTR VTS_BSTR VTS_BSTR VTS_VARIANT VTS_VARIANT;
  910. InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  911. Name, ConnectString, Query, &Position, &Options);
  912. return CMapXLayer(result);
  913. }
  915. void CMapXLayers::RemoveAll()
  916. {
  917. InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  918. }
  921. CMapXLayer CMapXLayers::GetInsertionLayer()
  922. {
  923. LPDISPATCH pDispatch;
  924. GetProperty(0xf, VT_DISPATCH, (void*)&pDispatch);
  925. return CMapXLayer(pDispatch);
  926. }
  928. void CMapXLayers::SetInsertionLayer(LPDISPATCH propVal)
  929. {
  930. SetProperty(0xf, VT_DISPATCH, propVal);
  931. }
  933. /////////////////////////////////////////////////////////////////////////////
  934. // CMapXLayer properties
  936. CString CMapXLayer::GetName()
  937. {
  938. CString result;
  939. GetProperty(0x1, VT_BSTR, (void*)&result);
  940. return result;
  941. }
  943. void CMapXLayer::SetName(LPCTSTR propVal)
  944. {
  945. SetProperty(0x1, VT_BSTR, propVal);
  946. }
  948. BOOL CMapXLayer::GetVisible()
  949. {
  950. BOOL result;
  951. GetProperty(0x2, VT_BOOL, (void*)&result);
  952. return result;
  953. }
  955. void CMapXLayer::SetVisible(BOOL propVal)
  956. {
  957. SetProperty(0x2, VT_BOOL, propVal);
  958. }
  960. BOOL CMapXLayer::GetSelectable()
  961. {
  962. BOOL result;
  963. GetProperty(0x3, VT_BOOL, (void*)&result);
  964. return result;
  965. }
  967. void CMapXLayer::SetSelectable(BOOL propVal)
  968. {
  969. SetProperty(0x3, VT_BOOL, propVal);
  970. }
  972. CString CMapXLayer::GetFilespec()
  973. {
  974. CString result;
  975. GetProperty(0x4, VT_BSTR, (void*)&result);
  976. return result;
  977. }
  979. CMapXLabelProperties CMapXLayer::GetLabelProperties()
  980. {
  981. LPDISPATCH result;
  982. GetProperty(0x5, VT_DISPATCH, (void*)&result);
  983. return CMapXLabelProperties(result);
  984. }
  986. BOOL CMapXLayer::GetAutoLabel()
  987. {
  988. BOOL result;
  989. GetProperty(0x6, VT_BOOL, (void*)&result);
  990. return result;
  991. }
  993. void CMapXLayer::SetAutoLabel(BOOL propVal)
  994. {
  995. SetProperty(0x6, VT_BOOL, propVal);
  996. }
  998. BOOL CMapXLayer::GetZoomLayer()
  999. {
  1000. BOOL result;
  1001. GetProperty(0x7, VT_BOOL, (void*)&result);
  1002. return result;
  1003. }
  1005. void CMapXLayer::SetZoomLayer(BOOL propVal)
  1006. {
  1007. SetProperty(0x7, VT_BOOL, propVal);
  1008. }
  1010. BOOL CMapXLayer::GetOverrideStyle()
  1011. {
  1012. BOOL result;
  1013. GetProperty(0x8, VT_BOOL, (void*)&result);
  1014. return result;
  1015. }
  1017. void CMapXLayer::SetOverrideStyle(BOOL propVal)
  1018. {
  1019. SetProperty(0x8, VT_BOOL, propVal);
  1020. }
  1022. CMapXStyle CMapXLayer::GetStyle()
  1023. {
  1024. LPDISPATCH result;
  1025. GetProperty(0x9, VT_DISPATCH, (void*)&result);
  1026. return CMapXStyle(result);
  1027. }
  1029. void CMapXLayer::SetStyle(LPDISPATCH propVal)
  1030. {
  1031. SetProperty(0x9, VT_DISPATCH, propVal);
  1032. }
  1034. double CMapXLayer::GetZoomMin()
  1035. {
  1036. double result;
  1037. GetProperty(0xa, VT_R8, (void*)&result);
  1038. return result;
  1039. }
  1041. void CMapXLayer::SetZoomMin(double propVal)
  1042. {
  1043. SetProperty(0xa, VT_R8, propVal);
  1044. }
  1046. double CMapXLayer::GetZoomMax()
  1047. {
  1048. double result;
  1049. GetProperty(0xb, VT_R8, (void*)&result);
  1050. return result;
  1051. }
  1053. void CMapXLayer::SetZoomMax(double propVal)
  1054. {
  1055. SetProperty(0xb, VT_R8, propVal);
  1056. }
  1058. CMapXSelection CMapXLayer::GetSelection()
  1059. {
  1060. LPDISPATCH result;
  1061. GetProperty(0xc, VT_DISPATCH, (void*)&result);
  1062. return CMapXSelection(result);
  1063. }
  1065. short CMapXLayer::GetPredominantFeatureType()
  1066. {
  1067. short result;
  1068. GetProperty(0xd, VT_I2, (void*)&result);
  1069. return result;
  1070. }
  1072. CMapXLayerFind CMapXLayer::GetFind()
  1073. {
  1074. LPDISPATCH result;
  1075. GetProperty(0xe, VT_DISPATCH, (void*)&result);
  1076. return CMapXLayerFind(result);
  1077. }
  1079. short CMapXLayer::GetType()
  1080. {
  1081. short result;
  1082. GetProperty(0xf, VT_I2, (void*)&result);
  1083. return result;
  1084. }
  1086. CString CMapXLayer::GetKeyField()
  1087. {
  1088. CString result;
  1089. GetProperty(0x10, VT_BSTR, (void*)&result);
  1090. return result;
  1091. }
  1093. void CMapXLayer::SetKeyField(LPCTSTR propVal)
  1094. {
  1095. SetProperty(0x10, VT_BSTR, propVal);
  1096. }
  1098. CMapXCoordSys CMapXLayer::GetCoordSys()
  1099. {
  1100. LPDISPATCH result;
  1101. GetProperty(0x11, VT_DISPATCH, (void*)&result);
  1102. return CMapXCoordSys(result);
  1103. }
  1105. CMapXRectangle CMapXLayer::GetBounds()
  1106. {
  1107. LPDISPATCH result;
  1108. GetProperty(0x20, VT_DISPATCH, (void*)&result);
  1109. return CMapXRectangle(result);
  1110. }
  1112. BOOL CMapXLayer::GetDrawLabelsAfter()
  1113. {
  1114. BOOL result;
  1115. GetProperty(0x25, VT_BOOL, (void*)&result);
  1116. return result;
  1117. }
  1119. void CMapXLayer::SetDrawLabelsAfter(BOOL propVal)
  1120. {
  1121. SetProperty(0x25, VT_BOOL, propVal);
  1122. }
  1124. CMapXDatasets CMapXLayer::GetDatasets()
  1125. {
  1126. LPDISPATCH result;
  1127. GetProperty(0x27, VT_DISPATCH, (void*)&result);
  1128. return CMapXDatasets(result);
  1129. }
  1131. BOOL CMapXLayer::GetShowNodes()
  1132. {
  1133. BOOL result;
  1134. GetProperty(0x2b, VT_BOOL, (void*)&result);
  1135. return result;
  1136. }
  1138. void CMapXLayer::SetShowNodes(BOOL propVal)
  1139. {
  1140. SetProperty(0x2b, VT_BOOL, propVal);
  1141. }
  1143. BOOL CMapXLayer::GetShowCentroids()
  1144. {
  1145. BOOL result;
  1146. GetProperty(0x2c, VT_BOOL, (void*)&result);
  1147. return result;
  1148. }
  1150. void CMapXLayer::SetShowCentroids(BOOL propVal)
  1151. {
  1152. SetProperty(0x2c, VT_BOOL, propVal);
  1153. }
  1155. BOOL CMapXLayer::GetShowLineDirection()
  1156. {
  1157. BOOL result;
  1158. GetProperty(0x2d, VT_BOOL, (void*)&result);
  1159. return result;
  1160. }
  1162. void CMapXLayer::SetShowLineDirection(BOOL propVal)
  1163. {
  1164. SetProperty(0x2d, VT_BOOL, propVal);
  1165. }
  1167. BOOL CMapXLayer::GetEditable()
  1168. {
  1169. BOOL result;
  1170. GetProperty(0x2e, VT_BOOL, (void*)&result);
  1171. return result;
  1172. }
  1174. void CMapXLayer::SetEditable(BOOL propVal)
  1175. {
  1176. SetProperty(0x2e, VT_BOOL, propVal);
  1177. }
  1179. /////////////////////////////////////////////////////////////////////////////
  1180. // CMapXLayer operations
  1182. void CMapXLayer::LabelAtPoint(double X, double Y)
  1183. {
  1184. static BYTE parms[] =
  1185. VTS_R8 VTS_R8;
  1186. InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1187.  X, Y);
  1188. }
  1190. void CMapXLayer::ClearCustomLabels()
  1191. {
  1192. InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1193. }
  1195. CMapXFeature CMapXLayer::AddFeature(LPDISPATCH Source, const VARIANT& RowValues)
  1196. {
  1197. LPDISPATCH result;
  1198. static BYTE parms[] =
  1199. VTS_DISPATCH VTS_VARIANT;
  1200. InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1201. Source, &RowValues);
  1202. return CMapXFeature(result);
  1203. }
  1205. void CMapXLayer::UpdateFeature(
  1206. const VARIANT& Target, 
  1207. const VARIANT& Source,
  1208. const VARIANT& RowValues)
  1209. {
  1210. static BYTE parms[] =
  1211. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1212. InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1213.  &Target, &Source, &RowValues);
  1214. }
  1216. void CMapXLayer::DeleteFeature(const VARIANT& Target)
  1217. {
  1218. static BYTE parms[] = VTS_VARIANT;
  1219. InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms, &Target);
  1220. }
  1222. void CMapXLayer::Invalidate(const VARIANT& InvalidRect)
  1223. {
  1224. static BYTE parms[] =
  1225. VTS_VARIANT;
  1226. InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1227.  &InvalidRect);
  1228. }
  1230. CMapXFeatures CMapXLayer::SearchWithinDistance(LPDISPATCH Source, double Distance, short Units, short SearchType)
  1231. {
  1232. LPDISPATCH result;
  1233. static BYTE parms[] =
  1234. VTS_DISPATCH VTS_R8 VTS_I2 VTS_I2;
  1235. InvokeHelper(0x18, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1236. Source, Distance, Units, SearchType);
  1237. return CMapXFeatures(result);
  1238. }
  1240. CMapXFeatures CMapXLayer::SearchWithinRectangle(LPDISPATCH Rectangle, short SearchType)
  1241. {
  1242. LPDISPATCH result;
  1243. static BYTE parms[] =
  1244. VTS_DISPATCH VTS_I2;
  1245. InvokeHelper(0x19, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1246. Rectangle, SearchType);
  1247. return CMapXFeatures(result);
  1248. }
  1250. CMapXFeatures CMapXLayer::AllFeatures()
  1251. {
  1252. LPDISPATCH result;
  1253. InvokeHelper(0x1a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  1254. return CMapXFeatures(result);
  1255. }
  1257. CMapXFeatures CMapXLayer::NoFeatures()
  1258. {
  1259. LPDISPATCH result;
  1260. InvokeHelper(0x1b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  1261. return CMapXFeatures(result);
  1262. }
  1264. CMapXFeatures CMapXLayer::SearchWithinFeature(LPDISPATCH Feature, short SearchType)
  1265. {
  1266. LPDISPATCH result;
  1267. static BYTE parms[] =
  1268. VTS_DISPATCH VTS_I2;
  1269. InvokeHelper(0x1c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1270. Feature, SearchType);
  1271. return CMapXFeatures(result);
  1272. }
  1274. CMapXFeatures CMapXLayer::SearchAtPoint(LPDISPATCH Point)
  1275. {
  1276. LPDISPATCH result;
  1277. static BYTE parms[] = VTS_DISPATCH;
  1278. InvokeHelper(0x1d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1279. Point);
  1280. return CMapXFeatures(result);
  1281. }
  1283. void CMapXLayer::DrillDownRemoveFeatures(LPCTSTR Level, const VARIANT& FeatureKeys)
  1284. {
  1285. static BYTE parms[] =
  1286. VTS_BSTR VTS_VARIANT;
  1287. InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1288.  Level, &FeatureKeys);
  1289. }
  1291. void CMapXLayer::DrillDownAddFeatures(LPCTSTR Level, const VARIANT& FeatureKeys)
  1292. {
  1293. static BYTE parms[] =
  1294. VTS_BSTR VTS_VARIANT;
  1295. InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1296.  Level, &FeatureKeys);
  1297. }
  1299. CMapXFeatures CMapXLayer::GetDrilldownFeaturesByID(LPCTSTR Level, const VARIANT& FeatureKeys)
  1300. {
  1301. LPDISPATCH result;
  1302. static BYTE parms[] =
  1303. VTS_BSTR VTS_VARIANT;
  1304. InvokeHelper(0x21, DISPATCH_METHOD, VT_DISPATCH, (void *)&result, parms,
  1305.  Level, &FeatureKeys);
  1306. return CMapXFeatures(result);
  1307. }
  1309. void CMapXLayer::DrilldownReset(LPCTSTR Level)
  1310. {
  1311. static BYTE parms[] =
  1312. VTS_BSTR;
  1313. InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1314.  Level);
  1315. }
  1317. CMapXFeature CMapXLayer::GetFeatureByID(long FeatureID)
  1318. {
  1319. LPDISPATCH result;
  1320. static BYTE parms[] =
  1321. VTS_I4;
  1322. InvokeHelper(0x23, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1323. FeatureID);
  1324. return CMapXFeature(result);
  1325. }
  1327. void CMapXLayer::Refresh()
  1328. {
  1329. InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1330. }
  1332. long CMapXLayer::FeatureIDFromFeatureName(LPCTSTR Name)
  1333. {
  1334. long result;
  1335. static BYTE parms[] =
  1336. VTS_BSTR;
  1337. InvokeHelper(0x26, DISPATCH_METHOD, VT_I4, &result, parms, Name);
  1338. return result;
  1339. }
  1341. CMapXFeatures CMapXLayer::Search(LPCTSTR strWhere, const VARIANT& Variables)
  1342. {
  1343. LPDISPATCH result;
  1344. static BYTE parms[] = VTS_BSTR VTS_VARIANT;
  1345. InvokeHelper(0x28, DISPATCH_METHOD, VT_DISPATCH, (void *)&result, parms, strWhere, &Variables);
  1346. return CMapXFeatures(result);
  1347. }
  1349. void CMapXLayer::BeginAccess(long BeginAccessType)
  1350. {
  1351. static BYTE parms[] = VTS_I2;
  1352. InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms, BeginAccessType);
  1353. }
  1355. void CMapXLayer::EndAccess(const VARIANT& EndAccessType)
  1356. {
  1357. static BYTE parms[] = VTS_VARIANT;
  1358. InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms, &EndAccessType);
  1359. }
  1361. CMapXFeature CMapXLayer::GetFeatureByKey(LPCTSTR FeatureKey)
  1362. {
  1363. LPDISPATCH result;
  1364. static BYTE parms[] = VTS_BSTR;
  1365. InvokeHelper(0x2f, DISPATCH_METHOD, VT_DISPATCH, (void *)&result, parms, FeatureKey);
  1366. return CMapXFeature(result);
  1367. }
  1369. CString CMapXLayer::FeatureKeyFromFeatureName(LPCTSTR strKeyValue)
  1370. {
  1371. CString result;
  1372. static BYTE parms[] = VTS_BSTR;
  1373. InvokeHelper(0x30, DISPATCH_METHOD, VT_BSTR, (void *)&result, parms, strKeyValue);
  1374. return result;
  1375. }
  1377. /////////////////////////////////////////////////////////////////////////////
  1378. // CMapXField properties
  1380. long CMapXField::GetType()
  1381. {
  1382. long result;
  1383. GetProperty(0x1, VT_I4, (void*)&result);
  1384. return result;
  1385. }
  1387. CString CMapXField::GetName()
  1388. {
  1389. CString result;
  1390. GetProperty(0x2, VT_BSTR, (void*)&result);
  1391. return result;
  1392. }
  1394. long CMapXField::GetAggregationFunction()
  1395. {
  1396. long result;
  1397. GetProperty(0x3, VT_I4, (void*)&result);
  1398. return result;
  1399. }
  1401. short CMapXField::GetWidth()
  1402. {
  1403. short result;
  1404. GetProperty(0x4, VT_I2, (void*)&result);
  1405. return result;
  1406. }
  1408. short CMapXField::GetPrecision()
  1409. {
  1410. short result;
  1411. GetProperty(0x5, VT_I2, (void*)&result);
  1412. return result;
  1413. }
  1415. short CMapXField::GetDecimals()
  1416. {
  1417. short result;
  1418. GetProperty(0x6, VT_I2, (void*)&result);
  1419. return result;
  1420. }
  1422. /////////////////////////////////////////////////////////////////////////////
  1423. // CMapXField operations
  1426. /////////////////////////////////////////////////////////////////////////////
  1427. // CMapXDataset properties
  1429. CString CMapXDataset::GetName()
  1430. {
  1431. CString result;
  1432. GetProperty(0x1, VT_BSTR, (void*)&result);
  1433. return result;
  1434. }
  1436. void CMapXDataset::SetName(LPCTSTR propVal)
  1437. {
  1438. SetProperty(0x1, VT_BSTR, propVal);
  1439. }
  1441. long CMapXDataset::GetRowCount()
  1442. {
  1443. long result;
  1444. GetProperty(0x2, VT_I4, (void*)&result);
  1445. return result;
  1446. }
  1448. CMapXFields CMapXDataset::GetFields()
  1449. {
  1450. LPDISPATCH result;
  1451. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  1452. return CMapXFields(result);
  1453. }
  1455. CMapXThemes CMapXDataset::GetThemes()
  1456. {
  1457. LPDISPATCH result;
  1458. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  1459. return CMapXThemes(result);
  1460. }
  1462. long CMapXDataset::GetGeoField()
  1463. {
  1464. long result;
  1465. GetProperty(0x5, VT_I4, (void*)&result);
  1466. return result;
  1467. }
  1469. long CMapXDataset::GetSecondaryGeoField()
  1470. {
  1471. long result;
  1472. GetProperty(0x6, VT_I4, (void*)&result);
  1473. return result;
  1474. }
  1476. CMapXLayer CMapXDataset::GetLayer()
  1477. {
  1478. LPDISPATCH result;
  1479. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  1480. return CMapXLayer(result);
  1481. }
  1483. short CMapXDataset::GetType()
  1484. {
  1485. short result;
  1486. GetProperty(0xb, VT_I2, (void*)&result);
  1487. return result;
  1488. }
  1490. BOOL CMapXDataset::GetReadOnly()
  1491. {
  1492. BOOL result;
  1493. GetProperty(0xc, VT_BOOL, (void*)&result);
  1494. return result;
  1495. }
  1497. /////////////////////////////////////////////////////////////////////////////
  1498. // CMapXDataset operations
  1500. void CMapXDataset::Refresh()
  1501. {
  1502. InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1503. }
  1505. VARIANT CMapXDataset::GetValue(const VARIANT& Row, const VARIANT& Column)
  1506. {
  1507. VARIANT result;
  1508. static BYTE parms[] =
  1509. VTS_VARIANT VTS_VARIANT;
  1510. InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
  1511. &Row, &Column);
  1512. return result;
  1513. }
  1515. CMapXSourceRows CMapXDataset::GetSourceRows(const VARIANT& Row)
  1516. {
  1517. LPDISPATCH result;
  1518. static BYTE parms[] =
  1519. VTS_VARIANT;
  1520. InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  1521. &Row);
  1522. return CMapXSourceRows(result);
  1523. }
  1525. CMapXRowValues CMapXDataset::GetRowValues(const VARIANT& Row)
  1526. {
  1527. LPDISPATCH result;
  1528. static BYTE parms[] =
  1529. VTS_VARIANT;
  1530. InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &Row);
  1531. return CMapXRowValues(result);
  1532. }
  1534. CMapXField CMapXDataset::AddField(LPCTSTR Name, LPCTSTR Expression)
  1535. {
  1536. LPDISPATCH result;
  1537. static BYTE parms[] = VTS_BSTR VTS_BSTR;
  1538. InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Name, Expression);
  1539. return CMapXField(result);
  1540. }
  1542. /////////////////////////////////////////////////////////////////////////////
  1543. // CMapXThemes properties
  1545. LPENUMVARIANT CMapXThemes::GetEnumerator()
  1546. {
  1547. LPENUMVARIANT pEnumVariant = 0;
  1548. LPUNKNOWN pUnknown = 0;
  1549. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  1550. if(pUnknown)
  1551. {
  1552. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  1553. pUnknown->Release();
  1554. }
  1555. return pEnumVariant;
  1556. }
  1558. long CMapXThemes::GetCount()
  1559. {
  1560. long result;
  1561. GetProperty(0x1, VT_I4, (void*)&result);
  1562. return result;
  1563. }
  1565. /////////////////////////////////////////////////////////////////////////////
  1566. // CMapXThemes operations
  1568. CMapXTheme CMapXThemes::Add(const VARIANT& Type, const VARIANT& Field, const VARIANT& Name, const VARIANT& ComputeTheme)
  1569. {
  1570. LPDISPATCH result;
  1571. static BYTE parms[] =
  1572. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1573. InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1574. &Type, &Field, &Name, &ComputeTheme);
  1575. return CMapXTheme(result);
  1576. }
  1578. CMapXTheme CMapXThemes::Item(const VARIANT& Index)
  1579. {
  1580. LPDISPATCH result;
  1581. static BYTE parms[] =
  1582. VTS_VARIANT;
  1583. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1584. &Index);
  1585. return CMapXTheme(result);
  1586. }
  1588. void CMapXThemes::Remove(const VARIANT& Index)
  1589. {
  1590. static BYTE parms[] =
  1591. VTS_VARIANT;
  1592. InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1593.  &Index);
  1594. }
  1596. void CMapXThemes::RemoveAll()
  1597. {
  1598. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1599. }
  1601. /////////////////////////////////////////////////////////////////////////////
  1602. // CMapXTheme properties
  1604. BOOL CMapXTheme::GetVisible()
  1605. {
  1606. BOOL result;
  1607. GetProperty(0x1, VT_BOOL, (void*)&result);
  1608. return result;
  1609. }
  1611. void CMapXTheme::SetVisible(BOOL propVal)
  1612. {
  1613. SetProperty(0x1, VT_BOOL, propVal);
  1614. }
  1616. short CMapXTheme::GetType()
  1617. {
  1618. short result;
  1619. GetProperty(0x2, VT_I2, (void*)&result);
  1620. return result;
  1621. }
  1623. CMapXThemeProperties CMapXTheme::GetProperties()
  1624. {
  1625. LPDISPATCH result;
  1626. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  1627. return CMapXThemeProperties(result);
  1628. }
  1630. CMapXLegend CMapXTheme::GetLegend()
  1631. {
  1632. LPDISPATCH result;
  1633. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  1634. return CMapXLegend(result);
  1635. }
  1637. BOOL CMapXTheme::GetAutoRecompute()
  1638. {
  1639. BOOL result;
  1640. GetProperty(0x5, VT_BOOL, (void*)&result);
  1641. return result;
  1642. }
  1644. void CMapXTheme::SetAutoRecompute(BOOL propVal)
  1645. {
  1646. SetProperty(0x5, VT_BOOL, propVal);
  1647. }
  1649. CString CMapXTheme::GetName()
  1650. {
  1651. CString result;
  1652. GetProperty(0x6, VT_BSTR, (void*)&result);
  1653. return result;
  1654. }
  1656. void CMapXTheme::SetName(LPCTSTR propVal)
  1657. {
  1658. SetProperty(0x6, VT_BSTR, propVal);
  1659. }
  1661. CMapXThemeProperties CMapXTheme::GetThemeProperties()
  1662. {
  1663. LPDISPATCH result;
  1664. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  1665. return CMapXThemeProperties(result);
  1666. }
  1668. CMapXLayer CMapXTheme::GetLayer()
  1669. {
  1670. LPDISPATCH result;
  1671. GetProperty(0x9, VT_DISPATCH, (void*)&result);
  1672. return CMapXLayer(result);
  1673. }
  1675. CMapXFields CMapXTheme::GetFields()
  1676. {
  1677. LPDISPATCH result;
  1678. GetProperty(0xa, VT_DISPATCH, (void*)&result);
  1679. return CMapXFields(result);
  1680. }
  1682. double CMapXTheme::GetDataMin()
  1683. {
  1684. double result;
  1685. GetProperty(0xb, VT_R8, (void*)&result);
  1686. return result;
  1687. }
  1689. void CMapXTheme::SetDataMin(double propVal)
  1690. {
  1691. SetProperty(0xb, VT_R8, propVal);
  1692. }
  1694. double CMapXTheme::GetDataMax()
  1695. {
  1696. double result;
  1697. GetProperty(0xc, VT_R8, (void*)&result);
  1698. return result;
  1699. }
  1701. void CMapXTheme::SetDataMax(double propVal)
  1702. {
  1703. SetProperty(0xc, VT_R8, propVal);
  1704. }
  1706. BOOL CMapXTheme::GetComputeTheme()
  1707. {
  1708. BOOL result;
  1709. GetProperty(0xd, VT_BOOL, (void*)&result);
  1710. return result;
  1711. }
  1713. void CMapXTheme::SetComputeTheme(BOOL propVal)
  1714. {
  1715. SetProperty(0xd, VT_BOOL, propVal);
  1716. }
  1718. /////////////////////////////////////////////////////////////////////////////
  1719. // CMapXTheme operations
  1721. BOOL CMapXTheme::ThemeDlg(const VARIANT& HelpFile, const VARIANT& HelpID)
  1722. {
  1723. BOOL bRetVal;
  1724. static BYTE parms[] =
  1725. VTS_VARIANT VTS_VARIANT;
  1726. InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&bRetVal, parms,
  1727. &HelpFile, &HelpID);
  1728. return bRetVal;
  1729. }
  1732. /////////////////////////////////////////////////////////////////////////////
  1733. // CMapXLegend properties
  1735. BOOL CMapXLegend::GetCompact()
  1736. {
  1737. BOOL result;
  1738. GetProperty(0x1, VT_BOOL, (void*)&result);
  1739. return result;
  1740. }
  1742. void CMapXLegend::SetCompact(BOOL propVal)
  1743. {
  1744. SetProperty(0x1, VT_BOOL, propVal);
  1745. }
  1747. BOOL CMapXLegend::GetVisible()
  1748. {
  1749. BOOL result;
  1750. GetProperty(0x2, VT_BOOL, (void*)&result);
  1751. return result;
  1752. }
  1754. void CMapXLegend::SetVisible(BOOL propVal)
  1755. {
  1756. SetProperty(0x2, VT_BOOL, propVal);
  1757. }
  1759. CMapXStyle CMapXLegend::GetTitleStyle()
  1760. {
  1761. LPDISPATCH result;
  1762. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  1763. return CMapXStyle(result);
  1764. }
  1766. void CMapXLegend::SetTitleStyle(LPDISPATCH propVal)
  1767. {
  1768. SetProperty(0x3, VT_DISPATCH, propVal);
  1769. }
  1771. CMapXStyle CMapXLegend::GetSubTitleStyle()
  1772. {
  1773. LPDISPATCH result;
  1774. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  1775. return CMapXStyle(result);
  1776. }
  1778. void CMapXLegend::SetSubTitleStyle(LPDISPATCH propVal)
  1779. {
  1780. SetProperty(0x4, VT_DISPATCH, propVal);
  1781. }
  1783. CMapXStyle CMapXLegend::GetCompactTitleStyle()
  1784. {
  1785. LPDISPATCH result;
  1786. GetProperty(0x5, VT_DISPATCH, (void*)&result);
  1787. return CMapXStyle(result);
  1788. }
  1790. void CMapXLegend::SetCompactTitleStyle(LPDISPATCH propVal)
  1791. {
  1792. SetProperty(0x5, VT_DISPATCH, propVal);
  1793. }
  1795. CMapXStyle CMapXLegend::GetBodyTextStyle()
  1796. {
  1797. LPDISPATCH result;
  1798. GetProperty(0x6, VT_DISPATCH, (void*)&result);
  1799. return CMapXStyle(result);
  1800. }
  1802. void CMapXLegend::SetBodyTextStyle(LPDISPATCH propVal)
  1803. {
  1804. SetProperty(0x6, VT_DISPATCH, propVal);
  1805. }
  1807. CMapXLegendTexts CMapXLegend::GetLegendTexts()
  1808. {
  1809. LPDISPATCH result;
  1810. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  1811. return CMapXLegendTexts(result);
  1812. }
  1814. BOOL CMapXLegend::GetCurrencyFormat()
  1815. {
  1816. BOOL result;
  1817. GetProperty(0x8, VT_BOOL, (void*)&result);
  1818. return result;
  1819. }
  1821. void CMapXLegend::SetCurrencyFormat(BOOL propVal)
  1822. {
  1823. SetProperty(0x8, VT_BOOL, propVal);
  1824. }
  1826. CString CMapXLegend::GetTitle()
  1827. {
  1828. CString result;
  1829. GetProperty(0x9, VT_BSTR, (void*)&result);
  1830. return result;
  1831. }
  1833. void CMapXLegend::SetTitle(LPCTSTR propVal)
  1834. {
  1835. SetProperty(0x9, VT_BSTR, propVal);
  1836. }
  1838. CString CMapXLegend::GetSubTitle()
  1839. {
  1840. CString result;
  1841. GetProperty(0xa, VT_BSTR, (void*)&result);
  1842. return result;
  1843. }
  1845. void CMapXLegend::SetSubTitle(LPCTSTR propVal)
  1846. {
  1847. SetProperty(0xa, VT_BSTR, propVal);
  1848. }
  1850. CString CMapXLegend::GetCompactTitle()
  1851. {
  1852. CString result;
  1853. GetProperty(0xb, VT_BSTR, (void*)&result);
  1854. return result;
  1855. }
  1857. void CMapXLegend::SetCompactTitle(LPCTSTR propVal)
  1858. {
  1859. SetProperty(0xb, VT_BSTR, propVal);
  1860. }
  1862. double CMapXLegend::GetLeft()
  1863. {
  1864. double result;
  1865. GetProperty(0xc, VT_R8, (void*)&result);
  1866. return result;
  1867. }
  1869. void CMapXLegend::SetLeft(double propVal)
  1870. {
  1871. SetProperty(0xc, VT_R8, propVal);
  1872. }
  1874. double CMapXLegend::GetTop()
  1875. {
  1876. double result;
  1877. GetProperty(0xd, VT_R8, (void*)&result);
  1878. return result;
  1879. }
  1881. void CMapXLegend::SetTop(double propVal)
  1882. {
  1883. SetProperty(0xd, VT_R8, propVal);
  1884. }
  1886. double CMapXLegend::GetWidth()
  1887. {
  1888. double result;
  1889. GetProperty(0xe, VT_R8, (void*)&result);
  1890. return result;
  1891. }
  1893. double CMapXLegend::GetHeight()
  1894. {
  1895. double result;
  1896. GetProperty(0xf, VT_R8, (void*)&result);
  1897. return result;
  1898. }
  1900. BOOL CMapXLegend::GetShowEmptyRanges()
  1901. {
  1902. BOOL result;
  1903. GetProperty(0x11, VT_BOOL, (void*)&result);
  1904. return result;
  1905. }
  1907. void CMapXLegend::SetShowEmptyRanges(BOOL propVal)
  1908. {
  1909. SetProperty(0x11, VT_BOOL, propVal);
  1910. }
  1912. BOOL CMapXLegend::GetShowCount()
  1913. {
  1914. BOOL result;
  1915. GetProperty(0x13, VT_BOOL, (void*)&result);
  1916. return result;
  1917. }
  1919. void CMapXLegend::SetShowCount(BOOL propVal)
  1920. {
  1921. SetProperty(0x13, VT_BOOL, propVal);
  1922. }
  1924. double CMapXLegend::GetPaperHeight()
  1925. {
  1926. double result;
  1927. GetProperty(0x15, VT_R8, (void*)&result);
  1928. return result;
  1929. }
  1931. double CMapXLegend::GetPaperWidth()
  1932. {
  1933. double result;
  1934. GetProperty(0x16, VT_R8, (void*)&result);
  1935. return result;
  1936. }
  1938. /////////////////////////////////////////////////////////////////////////////
  1939. // CMapXLegend operations
  1941. BOOL CMapXLegend::LegendDlg(const VARIANT& HelpFile, const VARIANT& HelpID)
  1942. {
  1943. BOOL bRetVal;
  1944. static BYTE parms[] =
  1945. VTS_VARIANT VTS_VARIANT;
  1946. InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&bRetVal, parms,
  1947. &HelpFile, &HelpID);
  1948. return(bRetVal);
  1949. }
  1951. void CMapXLegend::ExportLegend(LPCTSTR Destination, short Format)
  1952. {
  1953. static BYTE parms[] =
  1954. VTS_BSTR VTS_I2;
  1955. InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1956.  Destination, Format);
  1957. }
  1959. void CMapXLegend::PrintLegend(long hDC, long X, long Y, long W, long H)
  1960. {
  1961. static BYTE parms[] =
  1962. VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  1963. InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1964.  hDC, X, Y, W, H);
  1965. }
  1968. /////////////////////////////////////////////////////////////////////////////
  1969. // CMapXAnnotations properties
  1971. LPENUMVARIANT CMapXAnnotations::GetEnumerator()
  1972. {
  1973. LPENUMVARIANT pEnumVariant = 0;
  1974. LPUNKNOWN pUnknown = 0;
  1975. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  1976. if(pUnknown)
  1977. {
  1978. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  1979. pUnknown->Release();
  1980. }
  1981. return pEnumVariant;
  1982. }
  1984. BOOL CMapXAnnotations::GetEditable()
  1985. {
  1986. BOOL result;
  1987. GetProperty(0x1, VT_BOOL, (void*)&result);
  1988. return result;
  1989. }
  1991. void CMapXAnnotations::SetEditable(BOOL propVal)
  1992. {
  1993. SetProperty(0x1, VT_BOOL, propVal);
  1994. }
  1996. long CMapXAnnotations::GetCount()
  1997. {
  1998. long result;
  1999. GetProperty(0x2, VT_I4, (void*)&result);
  2000. return result;
  2001. }
  2003. /////////////////////////////////////////////////////////////////////////////
  2004. // CMapXAnnotations operations
  2006. CMapXAnnotation CMapXAnnotations::AddSymbol(double X, double Y)
  2007. {
  2008. LPDISPATCH result;
  2009. static BYTE parms[] =
  2010. VTS_R8 VTS_R8;
  2011. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2012. X, Y);
  2013. return CMapXAnnotation(result);
  2014. }
  2016. CMapXAnnotation CMapXAnnotations::Item(const VARIANT& Index)
  2017. {
  2018. LPDISPATCH result;
  2019. static BYTE parms[] =
  2020. VTS_VARIANT;
  2021. InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2022. &Index);
  2023. return CMapXAnnotation(result);
  2024. }
  2026. void CMapXAnnotations::Remove(const VARIANT& Index)
  2027. {
  2028. static BYTE parms[] =
  2029. VTS_VARIANT;
  2030. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2031.  &Index);
  2032. }
  2034. CMapXAnnotation CMapXAnnotations::AddText(LPCTSTR Text, double X, double Y, const VARIANT& Position)
  2035. {
  2036. LPDISPATCH result;
  2037. static BYTE parms[] =
  2038. VTS_BSTR VTS_R8 VTS_R8 VTS_VARIANT;
  2039. InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2040. Text, X, Y, &Position);
  2041. return CMapXAnnotation(result);
  2042. }
  2044. void CMapXAnnotations::RemoveAll()
  2045. {
  2046. InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2047. }
  2049. CMapXAnnotation CMapXAnnotations::ActiveAnnotation()
  2050. {
  2051. LPDISPATCH result;
  2052. GetProperty(0x8, VT_DISPATCH, (void*)&result);
  2053. return CMapXAnnotation(result);
  2054. }
  2057. /////////////////////////////////////////////////////////////////////////////
  2058. // CMapXThemeProperties properties
  2060. short CMapXThemeProperties::GetDistMethod()
  2061. {
  2062. short result;
  2063. GetProperty(0x1, VT_I2, (void*)&result);
  2064. return result;
  2065. }
  2067. void CMapXThemeProperties::SetDistMethod(short propVal)
  2068. {
  2069. SetProperty(0x1, VT_I2, propVal);
  2070. }
  2072. short CMapXThemeProperties::GetNumRanges()
  2073. {
  2074. short result;
  2075. GetProperty(0x2, VT_I2, (void*)&result);
  2076. return result;
  2077. }
  2079. void CMapXThemeProperties::SetNumRanges(short propVal)
  2080. {
  2081. SetProperty(0x2, VT_I2, propVal);
  2082. }
  2084. CMapXRangeCategories CMapXThemeProperties::GetRangeCategories()
  2085. {
  2086. LPDISPATCH result;
  2087. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  2088. return CMapXRangeCategories(result);
  2089. }
  2091. short CMapXThemeProperties::GetDotSize()
  2092. {
  2093. short result;
  2094. GetProperty(0x5, VT_I2, (void*)&result);
  2095. return result;
  2096. }
  2098. void CMapXThemeProperties::SetDotSize(short propVal)
  2099. {
  2100. SetProperty(0x5, VT_I2, propVal);
  2101. }
  2103. BOOL CMapXThemeProperties::GetGraduated()
  2104. {
  2105. BOOL result;
  2106. GetProperty(0x6, VT_BOOL, (void*)&result);
  2107. return result;
  2108. }
  2110. void CMapXThemeProperties::SetGraduated(BOOL propVal)
  2111. {
  2112. SetProperty(0x6, VT_BOOL, propVal);
  2113. }
  2115. CMapXMultivarCategories CMapXThemeProperties::GetMultivarCategories()
  2116. {
  2117. LPDISPATCH result;
  2118. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  2119. return CMapXMultivarCategories(result);
  2120. }
  2122. BOOL CMapXThemeProperties::GetIndependent()
  2123. {
  2124. BOOL result;
  2125. GetProperty(0x8, VT_BOOL, (void*)&result);
  2126. return result;
  2127. }
  2129. void CMapXThemeProperties::SetIndependent(BOOL propVal)
  2130. {
  2131. SetProperty(0x8, VT_BOOL, propVal);
  2132. }
  2134. CMapXIndividualValueCategories CMapXThemeProperties::GetIndividualValueCategories()
  2135. {
  2136. LPDISPATCH result;
  2137. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  2138. return CMapXIndividualValueCategories(result);
  2139. }
  2141. double CMapXThemeProperties::GetValuePerDot()
  2142. {
  2143. double result;
  2144. GetProperty(0x9, VT_R8, (void*)&result);
  2145. return result;
  2146. }
  2148. void CMapXThemeProperties::SetValuePerDot(double propVal)
  2149. {
  2150. SetProperty(0x9, VT_R8, propVal);
  2151. }
  2153. double CMapXThemeProperties::GetDataValue()
  2154. {
  2155. double result;
  2156. GetProperty(0xa, VT_R8, (void*)&result);
  2157. return result;
  2158. }
  2160. void CMapXThemeProperties::SetDataValue(double propVal)
  2161. {
  2162. SetProperty(0xa, VT_R8, propVal);
  2163. }
  2165. double CMapXThemeProperties::GetSize()
  2166. {
  2167. double result;
  2168. GetProperty(0xb, VT_R8, (void*)&result);
  2169. return result;
  2170. }
  2172. void CMapXThemeProperties::SetSize(double propVal)
  2173. {
  2174. SetProperty(0xb, VT_R8, propVal);
  2175. }
  2177. double CMapXThemeProperties::GetWidth()
  2178. {
  2179. double result;
  2180. GetProperty(0xc, VT_R8, (void*)&result);
  2181. return result;
  2182. }
  2184. void CMapXThemeProperties::SetWidth(double propVal)
  2185. {
  2186. SetProperty(0xc, VT_R8, propVal);
  2187. }
  2189. CMapXStyle CMapXThemeProperties::GetSymbolStyle()
  2190. {
  2191. LPDISPATCH result;
  2192. GetProperty(0xd, VT_DISPATCH, (void*)&result);
  2193. return CMapXStyle(result);
  2194. }
  2196. void CMapXThemeProperties::SetSymbolStyle(LPDISPATCH propVal)
  2197. {
  2198. SetProperty(0xd, VT_DISPATCH, propVal);
  2199. }
  2201. short CMapXThemeProperties::GetSpreadBy()
  2202. {
  2203. short result;
  2204. GetProperty(0xe, VT_I2, (void*)&result);
  2205. return result;
  2206. }
  2208. void CMapXThemeProperties::SetSpreadBy(short propVal)
  2209. {
  2210. SetProperty(0xe, VT_I2, propVal);
  2211. }
  2213. BOOL CMapXThemeProperties::GetAllowEmptyRanges()
  2214. {
  2215. BOOL result;
  2216. GetProperty(0xf, VT_BOOL, (void*)&result);
  2217. return result;
  2218. }
  2220. void CMapXThemeProperties::SetAllowEmptyRanges(BOOL propVal)
  2221. {
  2222. SetProperty(0xf, VT_BOOL, propVal);
  2223. }
  2225. unsigned long CMapXThemeProperties::GetDotColor()
  2226. {
  2227. unsigned long result;
  2228. GetProperty(0x10, VT_I4, (void*)&result);
  2229. return result;
  2230. }
  2232. void CMapXThemeProperties::SetDotColor(unsigned long propVal)
  2233. {
  2234. SetProperty(0x10, VT_I4, propVal);
  2235. }
  2237. BOOL CMapXThemeProperties::GetPieClockwise()
  2238. {
  2239. BOOL result;
  2240. GetProperty(0x11, VT_BOOL, (void*)&result);
  2241. return result;
  2242. }
  2244. void CMapXThemeProperties::SetPieClockwise(BOOL propVal)
  2245. {
  2246. SetProperty(0x11, VT_BOOL, propVal);
  2247. }
  2249. BOOL CMapXThemeProperties::GetPieHalfPies()
  2250. {
  2251. BOOL result;
  2252. GetProperty(0x12, VT_BOOL, (void*)&result);
  2253. return result;
  2254. }
  2256. void CMapXThemeProperties::SetPieHalfPies(BOOL propVal)
  2257. {
  2258. SetProperty(0x12, VT_BOOL, propVal);
  2259. }
  2261. short CMapXThemeProperties::GetPieStartAngle()
  2262. {
  2263. short result;
  2264. GetProperty(0x13, VT_I2, (void*)&result);
  2265. return result;
  2266. }
  2268. void CMapXThemeProperties::SetPieStartAngle(short propVal)
  2269. {
  2270. SetProperty(0x13, VT_I2, propVal);
  2271. }
  2273. BOOL CMapXThemeProperties::GetBarStacked()
  2274. {
  2275. BOOL result;
  2276. GetProperty(0x14, VT_BOOL, (void*)&result);
  2277. return result;
  2278. }
  2280. void CMapXThemeProperties::SetBarStacked(BOOL propVal)
  2281. {
  2282. SetProperty(0x14, VT_BOOL, propVal);
  2283. }
  2285. CMapXStyle CMapXThemeProperties::GetNegativeSymbolStyle()
  2286. {
  2287. LPDISPATCH result;
  2288. GetProperty(0x15, VT_DISPATCH, (void*)&result);
  2289. return CMapXStyle(result);
  2290. }
  2292. void CMapXThemeProperties::SetNegativeSymbolStyle(LPDISPATCH propVal)
  2293. {
  2294. SetProperty(0x15, VT_DISPATCH, propVal);
  2295. }
  2297. BOOL CMapXThemeProperties::GetShowNegativeValues()
  2298. {
  2299. BOOL result;
  2300. GetProperty(0x16, VT_BOOL, (void*)&result);
  2301. return result;
  2302. }
  2304. void CMapXThemeProperties::SetShowNegativeValues(BOOL propVal)
  2305. {
  2306. SetProperty(0x16, VT_BOOL, propVal);
  2307. }
  2309. short CMapXThemeProperties::GetGraduateSizeBy()
  2310. {
  2311. short result;
  2312. GetProperty(0x17, VT_I2, (void*)&result);
  2313. return result;
  2314. }
  2316. void CMapXThemeProperties::SetGraduateSizeBy(short propVal)
  2317. {
  2318. SetProperty(0x17, VT_I2, propVal);
  2319. }
  2321. CMapXStyle CMapXThemeProperties::GetBorderStyle()
  2322. {
  2323. LPDISPATCH result;
  2324. GetProperty(0x18, VT_DISPATCH, (void*)&result);
  2325. return CMapXStyle(result);
  2326. }
  2328. void CMapXThemeProperties::SetBorderStyle(LPDISPATCH propVal)
  2329. {
  2330. SetProperty(0x18, VT_DISPATCH, propVal);
  2331. }
  2333. double CMapXThemeProperties::GetBarWidth()
  2334. {
  2335. double result;
  2336. GetProperty(0x19, VT_R8, (void*)&result);
  2337. return result;
  2338. }
  2340. void CMapXThemeProperties::SetBarWidth(double propVal)
  2341. {
  2342. SetProperty(0x19, VT_R8, propVal);
  2343. }
  2345. BOOL CMapXThemeProperties::GetBarIndependentScale()
  2346. {
  2347. BOOL result;
  2348. GetProperty(0x1a, VT_BOOL, (void*)&result);
  2349. return result;
  2350. }
  2352. void CMapXThemeProperties::SetBarIndependentScale(BOOL propVal)
  2353. {
  2354. SetProperty(0x1a, VT_BOOL, propVal);
  2355. }
  2357. CMapXStyle CMapXThemeProperties::GetPositiveSymbolStyle()
  2358. {
  2359. LPDISPATCH result;
  2360. GetProperty(0x1b, VT_DISPATCH, (void*)&result);
  2361. return CMapXStyle(result);
  2362. }
  2364. void CMapXThemeProperties::SetPositiveSymbolStyle(LPDISPATCH propVal)
  2365. {
  2366. SetProperty(0x1b, VT_DISPATCH, propVal);
  2367. }
  2369. CMapXStyle CMapXThemeProperties::GetBarFrameStyle()
  2370. {
  2371. LPDISPATCH result;
  2372. GetProperty(0x1c, VT_DISPATCH, (void*)&result);
  2373. return CMapXStyle(result);
  2374. }
  2376. void CMapXThemeProperties::SetBarFrameStyle(LPDISPATCH propVal)
  2377. {
  2378. SetProperty(0x1c, VT_DISPATCH, propVal);
  2379. }
  2381. BOOL CMapXThemeProperties::GetPieGraduated()
  2382. {
  2383. BOOL result;
  2384. GetProperty(0x1d, VT_BOOL, (void*)&result);
  2385. return result;
  2386. }
  2388. void CMapXThemeProperties::SetPieGraduated(BOOL propVal)
  2389. {
  2390. SetProperty(0x1d, VT_BOOL, propVal);
  2391. }
  2393. BOOL CMapXThemeProperties::GetBarGraduatedStack()
  2394. {
  2395. BOOL result;
  2396. GetProperty(0x1e, VT_BOOL, (void*)&result);
  2397. return result;
  2398. }
  2400. void CMapXThemeProperties::SetBarGraduatedStack(BOOL propVal)
  2401. {
  2402. SetProperty(0x1e, VT_BOOL, propVal);
  2403. }
  2405. short CMapXThemeProperties::GetApplyAttribute()
  2406. {
  2407. short result;
  2408. GetProperty(0x1f, VT_I2, (void*)&result);
  2409. return result;
  2410. }
  2412. void CMapXThemeProperties::SetApplyAttribute(short propVal)
  2413. {
  2414. SetProperty(0x1f, VT_I2, propVal);
  2415. }
  2417. BOOL CMapXThemeProperties::GetRoundRanges()
  2418. {
  2419. BOOL result;
  2420. GetProperty(0x20, VT_BOOL, (void*)&result);
  2421. return result;
  2422. }
  2424. void CMapXThemeProperties::SetRoundRanges(BOOL propVal)
  2425. {
  2426. SetProperty(0x20, VT_BOOL, propVal);
  2427. }
  2429. double CMapXThemeProperties::GetRoundBy()
  2430. {
  2431. double result;
  2432. GetProperty(0x21, VT_R8, (void*)&result);
  2433. return result;
  2434. }
  2436. void CMapXThemeProperties::SetRoundBy(double propVal)
  2437. {
  2438. SetProperty(0x21, VT_R8, propVal);
  2439. }
  2441. short CMapXThemeProperties::GetColorMethod()
  2442. {
  2443. short result;
  2444. GetProperty(0x22, VT_I2, (void*)&result);
  2445. return result;
  2446. }
  2448. void CMapXThemeProperties::SetColorMethod(short propVal)
  2449. {
  2450. SetProperty(0x22, VT_I2, propVal);
  2451. }
  2453. BOOL CMapXThemeProperties::GetInflectRanges()
  2454. {
  2455. BOOL result;
  2456. GetProperty(0x23, VT_BOOL, (void*)&result);
  2457. return result;
  2458. }
  2460. void CMapXThemeProperties::SetInflectRanges(BOOL propVal)
  2461. {
  2462. SetProperty(0x23, VT_BOOL, propVal);
  2463. }
  2465. short CMapXThemeProperties::GetInflectionRange()
  2466. {
  2467. short result;
  2468. GetProperty(0x24, VT_I2, (void*)&result);
  2469. return result;
  2470. }
  2472. void CMapXThemeProperties::SetInflectionRange(short propVal)
  2473. {
  2474. SetProperty(0x24, VT_I2, propVal);
  2475. }
  2477. unsigned long CMapXThemeProperties::GetInflectionColor()
  2478. {
  2479. unsigned long result;
  2480. GetProperty(0x25, VT_I4, (void*)&result);
  2481. return result;
  2482. }
  2484. void CMapXThemeProperties::SetInflectionColor(unsigned long propVal)
  2485. {
  2486. SetProperty(0x25, VT_I4, propVal);
  2487. }
  2489. BOOL CMapXThemeProperties::GetBarFramed()
  2490. {
  2491. BOOL result;
  2492. GetProperty(0x26, VT_BOOL, (void*)&result);
  2493. return result;
  2494. }
  2496. void CMapXThemeProperties::SetBarFramed(BOOL propVal)
  2497. {
  2498. SetProperty(0x26, VT_BOOL, propVal);
  2499. }
  2501. /////////////////////////////////////////////////////////////////////////////
  2502. // CMapXThemeProperties operations
  2505. /////////////////////////////////////////////////////////////////////////////
  2506. // CMapXSelection properties
  2508. LPENUMVARIANT CMapXSelection::GetEnumerator()
  2509. {
  2510. LPENUMVARIANT pEnumVariant = 0;
  2511. LPUNKNOWN pUnknown = 0;
  2512. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  2513. if(pUnknown)
  2514. {
  2515. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  2516. pUnknown->Release();
  2517. }
  2518. return pEnumVariant;
  2519. }
  2521. long CMapXSelection::GetCount()
  2522. {
  2523. long result;
  2524. GetProperty(0x10001, VT_I4, (void*)&result);
  2525. return result;
  2526. }
  2528. CMapXRectangle CMapXSelection::GetBounds()
  2529. {
  2530. LPDISPATCH result;
  2531. GetProperty(0x10008, VT_DISPATCH, (void*)&result);
  2532. return CMapXRectangle(result);
  2533. }
  2535. /////////////////////////////////////////////////////////////////////////////
  2536. // CMapXSelection operations
  2538. CMapXFeature CMapXSelection::Item(const VARIANT& Index)
  2539. {
  2540. LPDISPATCH result;
  2541. static BYTE parms[] =
  2542. VTS_VARIANT;
  2543. InvokeHelper(0x10002, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2544. &Index);
  2545. return CMapXFeature(result);
  2546. }
  2548. CMapXFeatures CMapXSelection::Clone()
  2549. {
  2550. LPDISPATCH result;
  2551. InvokeHelper(0x10003, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  2552. return CMapXFeatures(result);
  2553. }
  2555. void CMapXSelection::Add(LPDISPATCH Source)
  2556. {
  2557. static BYTE parms[] =
  2558. VTS_DISPATCH;
  2559. InvokeHelper(0x10004, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2560.  Source);
  2561. }
  2563. void CMapXSelection::Common(LPDISPATCH Source)
  2564. {
  2565. static BYTE parms[] =
  2566. VTS_DISPATCH;
  2567. InvokeHelper(0x10005, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2568.  Source);
  2569. }
  2571. void CMapXSelection::Remove(const VARIANT& Source)
  2572. {
  2573. static BYTE parms[] =
  2574. VTS_VARIANT;
  2575. InvokeHelper(0x10006, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2576.  &Source);
  2577. }
  2579. void CMapXSelection::Replace(LPDISPATCH Source)
  2580. {
  2581. static BYTE parms[] =
  2582. VTS_DISPATCH;
  2583. InvokeHelper(0x10007, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2584.  Source);
  2585. }
  2587. void CMapXSelection::AddByID(const VARIANT& FeatureID)
  2588. {
  2589. static BYTE parms[] =
  2590. VTS_VARIANT;
  2591. InvokeHelper(0x10009, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2592.  &FeatureID);
  2593. }
  2595. void CMapXSelection::RemoveByID(const VARIANT& FeatureID)
  2596. {
  2597. static BYTE parms[] =
  2598. VTS_VARIANT;
  2599. InvokeHelper(0x1000a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2600.  &FeatureID);
  2601. }
  2603. void CMapXSelection::SelectByRegion(LPDISPATCH Layer, const VARIANT& FeatureID, short Flag)
  2604. {
  2605. static BYTE parms[] =
  2606. VTS_DISPATCH VTS_VARIANT VTS_I2;
  2607. InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2608.  Layer, &FeatureID, Flag);
  2609. }
  2611. void CMapXSelection::ClearSelection()
  2612. {
  2613. InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2614. }
  2616. void CMapXSelection::SelectByPoint(double X, double Y, short Flag)
  2617. {
  2618. static BYTE parms[] =
  2619. VTS_R8 VTS_R8 VTS_I2;
  2620. InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2621.  X, Y, Flag);
  2622. }
  2624. void CMapXSelection::SelectByRadius(double X, double Y, double radius, short Flag)
  2625. {
  2626. static BYTE parms[] =
  2627. VTS_R8 VTS_R8 VTS_R8 VTS_I2;
  2628. InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2629.  X, Y, radius, Flag);
  2630. }
  2632. void CMapXSelection::SelectByRectangle(double X1, double Y1, double X2, double Y2, short Flag)
  2633. {
  2634. static BYTE parms[] =
  2635. VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_I2;
  2636. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2637.  X1, Y1, X2, Y2, Flag);
  2638. }
  2640. BOOL CMapXSelection::SelectAll(short Flag)
  2641. {
  2642. BOOL result;
  2643. static BYTE parms[] =
  2644. VTS_I2;
  2645. InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  2646. Flag);
  2647. return result;
  2648. }
  2650. void CMapXSelection::SelectByID(const VARIANT& FeatureID, short Flag)
  2651. {
  2652. static BYTE parms[] =
  2653. VTS_VARIANT VTS_I2;
  2654. InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2655.  &FeatureID, Flag);
  2656. }
  2659. /////////////////////////////////////////////////////////////////////////////
  2660. // CMapXFeature properties
  2662. long CMapXFeature::GetFeatureID()
  2663. {
  2664. long result;
  2665. GetProperty(0x1, VT_I4, (void*)&result);
  2666. return result;
  2667. }
  2669. short CMapXFeature::GetType()
  2670. {
  2671. short result;
  2672. GetProperty(0x2, VT_I2, (void*)&result);
  2673. return result;
  2674. }
  2676. void CMapXFeature::SetType(short propVal)
  2677. {
  2678. SetProperty(0x2, VT_I2, propVal);
  2679. }
  2681. double CMapXFeature::GetLength()
  2682. {
  2683. double result;
  2684. GetProperty(0x3, VT_R8, (void*)&result);
  2685. return result;
  2686. }
  2688. double CMapXFeature::GetCenterX()
  2689. {
  2690. double result;
  2691. GetProperty(0x4, VT_R8, (void*)&result);
  2692. return result;
  2693. }
  2695. double CMapXFeature::GetCenterY()
  2696. {
  2697. double result;
  2698. GetProperty(0x5, VT_R8, (void*)&result);
  2699. return result;
  2700. }
  2702. CMapXStyle CMapXFeature::GetStyle()
  2703. {
  2704. LPDISPATCH result;
  2705. GetProperty(0x6, VT_DISPATCH, (void*)&result);
  2706. return CMapXStyle(result);
  2707. }
  2709. void CMapXFeature::SetStyle(LPDISPATCH propVal)
  2710. {
  2711. SetProperty(0x6, VT_DISPATCH, propVal);
  2712. }
  2714. CMapXRectangle CMapXFeature::GetBounds()
  2715. {
  2716. LPDISPATCH result;
  2717. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  2718. return CMapXRectangle(result);
  2719. }
  2721. CString CMapXFeature::GetCaption()
  2722. {
  2723. CString result;
  2724. GetProperty(0x8, VT_BSTR, (void*)&result);
  2725. return result;
  2726. }
  2728. void CMapXFeature::SetCaption(LPCTSTR propVal)
  2729. {
  2730. SetProperty(0x8, VT_BSTR, propVal);
  2731. }
  2733. CMapXParts CMapXFeature::GetParts()
  2734. {
  2735. LPDISPATCH result;
  2736. GetProperty(0x9, VT_DISPATCH, (void*)&result);
  2737. return CMapXParts(result);
  2738. }
  2740. double CMapXFeature::GetArea()
  2741. {
  2742. double result;
  2743. GetProperty(0xa, VT_R8, (void*)&result);
  2744. return result;
  2745. }
  2747. CMapXLayer CMapXFeature::GetLayer()
  2748. {
  2749. LPDISPATCH result;
  2750. GetProperty(0xb, VT_DISPATCH, (void*)&result);
  2751. return CMapXLayer(result);
  2752. }
  2754. CMapXPoint CMapXFeature::GetPoint()
  2755. {
  2756. LPDISPATCH result;
  2757. GetProperty(0xc, VT_DISPATCH, (void*)&result);
  2758. return CMapXPoint(result);
  2759. }
  2761. void CMapXFeature::SetPoint(LPDISPATCH propVal)
  2762. {
  2763. SetProperty(0xc, VT_DISPATCH, propVal);
  2764. }
  2766. CMapXPoint CMapXFeature::GetLabelPoint()
  2767. {
  2768. LPDISPATCH result;
  2769. GetProperty(0xd, VT_DISPATCH, (void*)&result);
  2770. return CMapXPoint(result);
  2771. }
  2773. double CMapXFeature::GetPerimeter()
  2774. {
  2775. double result;
  2776. GetProperty(0xe, VT_R8, (void*)&result);
  2777. return result;
  2778. }
  2780. BOOL CMapXFeature::GetSmooth()
  2781. {
  2782. BOOL result;
  2783. GetProperty(0xf, VT_BOOL, (void*)&result);
  2784. return result;
  2785. }
  2787. void CMapXFeature::SetSmooth(BOOL propVal)
  2788. {
  2789. SetProperty(0xf, VT_BOOL, propVal);
  2790. }
  2792. CString CMapXFeature::GetName()
  2793. {
  2794. CString result;
  2795. GetProperty(0x10, VT_BSTR, (void*)&result);
  2796. return result;
  2797. }
  2799. CString CMapXFeature::GetKeyValue()
  2800. {
  2801. CString result;
  2802. GetProperty(0x11, VT_BSTR, (void*)&result);
  2803. return result;
  2804. }
  2806. void CMapXFeature::SetKeyValue(LPCTSTR propVal)
  2807. {
  2808. SetProperty(0x11, VT_BSTR, propVal);
  2809. }
  2811. CString CMapXFeature::GetFeatureKey()
  2812. {
  2813. CString result;
  2814. GetProperty(0x17, VT_BSTR, (void*)&result);
  2815. return result;
  2816. }
  2818. /////////////////////////////////////////////////////////////////////////////
  2819. // CMapXFeature operations
  2821. void CMapXFeature::Update(const VARIANT& UpdateFeature, const VARIANT& RowValues)
  2822. {
  2823. static BYTE parms[] =
  2824. VTS_VARIANT VTS_VARIANT;
  2825. InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms, &UpdateFeature, &RowValues);
  2826. }
  2828. void CMapXFeature::Offset(double deltaX, double deltaY)
  2829. {
  2830. static BYTE parms[] =
  2831. VTS_R8 VTS_R8;
  2832. InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2833.  deltaX, deltaY);
  2834. }
  2836. void CMapXFeature::Attach(LPDISPATCH Map)
  2837. {
  2838. static BYTE parms[] =
  2839. VTS_DISPATCH;
  2840. InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms, Map);
  2841. }
  2843. CMapXFeature CMapXFeature::Clone()
  2844. {
  2845. LPDISPATCH result;
  2846. InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  2847. return CMapXFeature(result);
  2848. }
  2850. VARIANT CMapXFeature::Nodes(const VARIANT& CSys)
  2851. {
  2852. VARIANT result;
  2853. static BYTE parms[] = VTS_VARIANT;
  2854. InvokeHelper(0x16, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &CSys);
  2855. return result;
  2856. }
  2858. VARIANT CMapXFeature::GetNodes(const VARIANT& CSys)
  2859. {
  2860. VARIANT result;
  2861. static BYTE parms[] =
  2862. VTS_VARIANT;
  2863. InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
  2864. &CSys);
  2865. return result;
  2866. }
  2868. void CMapXFeature::SetNodes(const VARIANT& CSys, const VARIANT& newValue)
  2869. {
  2870. static BYTE parms[] =
  2871. VTS_VARIANT VTS_VARIANT;
  2872. InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2873.  &CSys, &newValue);
  2874. }
  2876. /////////////////////////////////////////////////////////////////////////////
  2877. // CMapXFeatureFactory properties
  2879. /////////////////////////////////////////////////////////////////////////////
  2880. // CMapXFeatureFactory operations
  2882. CMapXFeature CMapXFeatureFactory::BufferFeatures(LPDISPATCH Source, double Distance, const VARIANT& Units, const VARIANT& Resolution)
  2883. {
  2884. LPDISPATCH result;
  2885. static BYTE parms[] =
  2886. VTS_DISPATCH VTS_R8 VTS_VARIANT VTS_VARIANT;
  2887. InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2888. Source, Distance, &Units, &Resolution);
  2889. return CMapXFeature(result);
  2890. }
  2892. CMapXFeature CMapXFeatureFactory::CombineFeatures(LPDISPATCH Source1, const VARIANT& Source2)
  2893. {
  2894. LPDISPATCH result;
  2895. static BYTE parms[] =
  2896. VTS_DISPATCH VTS_VARIANT;
  2897. InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2898. Source1, &Source2);
  2899. return CMapXFeature(result);
  2900. }
  2902. CMapXFeature CMapXFeatureFactory::IntersectFeatures(LPDISPATCH Source1, const VARIANT& Source2)
  2903. {
  2904. LPDISPATCH result;
  2905. static BYTE parms[] =
  2906. VTS_DISPATCH VTS_VARIANT;
  2907. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2908. Source1, &Source2);
  2909. return CMapXFeature(result);
  2910. }
  2912. CMapXFeature CMapXFeatureFactory::EraseFeature(LPDISPATCH Feature, LPDISPATCH EraserFeature)
  2913. {
  2914. LPDISPATCH result;
  2915. static BYTE parms[] =
  2916. VTS_DISPATCH VTS_DISPATCH;
  2917. InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2918. Feature, EraserFeature);
  2919. return CMapXFeature(result);
  2920. }
  2922. CMapXFeature CMapXFeatureFactory::CreateSymbol(const VARIANT& Point, const VARIANT& Style)
  2923. {
  2924. LPDISPATCH result;
  2925. static BYTE parms[] =
  2926. VTS_VARIANT VTS_VARIANT;
  2927. InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2928. &Point, &Style);
  2929. return CMapXFeature(result);
  2930. }
  2932. CMapXFeature CMapXFeatureFactory::CreateRegion(const VARIANT& Points, const VARIANT& Style)
  2933. {
  2934. LPDISPATCH result;
  2935. static BYTE parms[] =
  2936. VTS_VARIANT VTS_VARIANT;
  2937. InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2938. &Points, &Style);
  2939. return CMapXFeature(result);
  2940. }
  2942. CMapXFeature CMapXFeatureFactory::CreateLine(const VARIANT& Points, const VARIANT& Style)
  2943. {
  2944. LPDISPATCH result;
  2945. static BYTE parms[] =
  2946. VTS_VARIANT VTS_VARIANT;
  2947. InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2948. &Points, &Style);
  2949. return CMapXFeature(result);
  2950. }
  2952. CMapXFeature CMapXFeatureFactory::CreateText(const VARIANT& Point, const VARIANT& Caption, const VARIANT& Position, const VARIANT& Style)
  2953. {
  2954. LPDISPATCH result;
  2955. static BYTE parms[] =
  2956. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  2957. InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2958. &Point, &Caption, &Position, &Style);
  2959. return CMapXFeature(result);
  2960. }
  2962. CMapXFeature CMapXFeatureFactory::CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, const VARIANT& Angle, const VARIANT& Distance, const VARIANT& Resolution, const VARIANT& Style)
  2963. {
  2964. LPDISPATCH result;
  2965. static BYTE parms[] =
  2966. VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  2967. InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2968. Point1, Point2, &Angle, &Distance, &Resolution, &Style);
  2969. return CMapXFeature(result);
  2970. }
  2972. CMapXFeature CMapXFeatureFactory::CreateEllipticalRegion(LPDISPATCH Rectangle, const VARIANT& Angle, const VARIANT& Resolution, const VARIANT& Style)
  2973. {
  2974. LPDISPATCH result;
  2975. static BYTE parms[] =
  2976. VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  2977. InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2978. Rectangle, &Angle, &Resolution, &Style);
  2979. return CMapXFeature(result);
  2980. }
  2982. CMapXFeature CMapXFeatureFactory::CreateCircularRegion(short Type, LPDISPATCH Point, double Distance, const VARIANT& Units, const VARIANT& Resolution, const VARIANT& Style)
  2983. {
  2984. LPDISPATCH result;
  2985. static BYTE parms[] =
  2986. VTS_I2 VTS_DISPATCH VTS_R8 VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  2987. InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2988. Type, Point, Distance, &Units, &Resolution, &Style);
  2989. return CMapXFeature(result);
  2990. }
  2992. BOOL CMapXFeatureFactory::IntersectionTest(LPDISPATCH Feature1, LPDISPATCH Feature2, const VARIANT& Flag)
  2993. {
  2994. BOOL result;
  2995. static BYTE parms[] =
  2996. VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
  2997. InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  2998. Feature1, Feature2, &Flag);
  2999. return result;
  3000. }
  3002. CMapXPoints CMapXFeatureFactory::IntersectionPoints(LPDISPATCH Feature1, LPDISPATCH Feature2, const VARIANT& Flag)
  3003. {
  3004. LPDISPATCH result;
  3005. static BYTE parms[] =
  3006. VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
  3007. InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3008. Feature1, Feature2, &Flag);
  3009. return CMapXPoints(result);
  3010. }
  3013. /////////////////////////////////////////////////////////////////////////////
  3014. // CMapXRangeCategory properties
  3016. double CMapXRangeCategory::GetMin()
  3017. {
  3018. double result;
  3019. GetProperty(0x1, VT_R8, (void*)&result);
  3020. return result;
  3021. }
  3023. void CMapXRangeCategory::SetMin(double propVal)
  3024. {
  3025. SetProperty(0x1, VT_R8, propVal);
  3026. }
  3028. double CMapXRangeCategory::GetMax()
  3029. {
  3030. double result;
  3031. GetProperty(0x2, VT_R8, (void*)&result);
  3032. return result;
  3033. }
  3035. void CMapXRangeCategory::SetMax(double propVal)
  3036. {
  3037. SetProperty(0x2, VT_R8, propVal);
  3038. }
  3040. long CMapXRangeCategory::GetNumItems()
  3041. {
  3042. long result;
  3043. GetProperty(0x3, VT_I4, (void*)&result);
  3044. return result;
  3045. }
  3047. CMapXStyle CMapXRangeCategory::GetStyle()
  3048. {
  3049. LPDISPATCH result;
  3050. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  3051. return CMapXStyle(result);
  3052. }
  3054. void CMapXRangeCategory::SetStyle(LPDISPATCH propVal)
  3055. {
  3056. SetProperty(0x4, VT_DISPATCH, propVal);
  3057. }
  3059. /////////////////////////////////////////////////////////////////////////////
  3060. // CMapXRangeCategory operations
  3063. /////////////////////////////////////////////////////////////////////////////
  3064. // CMapXFields properties
  3066. LPENUMVARIANT CMapXFields::GetEnumerator()
  3067. {
  3068. LPENUMVARIANT pEnumVariant = 0;
  3069. LPUNKNOWN pUnknown = 0;
  3070. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  3071. if(pUnknown)
  3072. {
  3073. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  3074. pUnknown->Release();
  3075. }
  3076. return pEnumVariant;
  3077. }
  3079. long CMapXFields::GetCount()
  3080. {
  3081. long result;
  3082. GetProperty(0x1, VT_I4, (void*)&result);
  3083. return result;
  3084. }
  3086. /////////////////////////////////////////////////////////////////////////////
  3087. // CMapXFields operations
  3089. CMapXField CMapXFields::Add(const VARIANT& SourceField, const VARIANT& Name, const VARIANT& AggregationFunction, const VARIANT& Type)
  3090. {
  3091. LPDISPATCH result;
  3092. static BYTE parms[] =
  3093. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3094. InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3095. &SourceField, &Name, &AggregationFunction, &Type);
  3096. return CMapXField(result);
  3097. }
  3099. CMapXField CMapXFields::Item(const VARIANT& Index)
  3100. {
  3101. LPDISPATCH result;
  3102. static BYTE parms[] =
  3103. VTS_VARIANT;
  3104. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3105. &Index);
  3106. return CMapXField(result);
  3107. }
  3109. void CMapXFields::Remove(const VARIANT& Index)
  3110. {
  3111. static BYTE parms[] =
  3112. VTS_VARIANT;
  3113. InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  3114.  &Index);
  3115. }
  3117. void CMapXFields::RemoveAll()
  3118. {
  3119. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  3120. }
  3122. CMapXField CMapXFields::AddStringField(const VARIANT& Name, const VARIANT& Width)
  3123. {
  3124. LPDISPATCH result;
  3125. static BYTE parms[] =
  3126. VTS_VARIANT VTS_VARIANT;
  3127. InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3128. &Name, &Width);
  3129. return CMapXField(result);
  3130. }
  3132. CMapXField CMapXFields::AddLogicalField(const VARIANT& Name)
  3133. {
  3134. LPDISPATCH result;
  3135. static BYTE parms[] =
  3136. VTS_VARIANT;
  3137. InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3138. &Name);
  3139. return CMapXField(result);
  3140. }
  3142. CMapXField CMapXFields::AddIntegerField(const VARIANT& Name)
  3143. {
  3144. LPDISPATCH result;
  3145. static BYTE parms[] =
  3146. VTS_VARIANT;
  3147. InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3148. &Name);
  3149. return CMapXField(result);
  3150. }
  3152. CMapXField CMapXFields::AddSmallIntField(const VARIANT& Name)
  3153. {
  3154. LPDISPATCH result;
  3155. static BYTE parms[] =
  3156. VTS_VARIANT;
  3157. InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3158. &Name);
  3159. return CMapXField(result);
  3160. }
  3162. CMapXField CMapXFields::AddNumericField(const VARIANT& Name, const VARIANT& Precision, const VARIANT& Decimals)
  3163. {
  3164. LPDISPATCH result;
  3165. static BYTE parms[] =
  3166. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3167. InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3168. &Name, &Precision, &Decimals);
  3169. return CMapXField(result);
  3170. }
  3172. CMapXField CMapXFields::AddFloatField(const VARIANT& Name)
  3173. {
  3174. LPDISPATCH result;
  3175. static BYTE parms[] =
  3176. VTS_VARIANT;
  3177. InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3178. &Name);
  3179. return CMapXField(result);
  3180. }
  3182. CMapXField CMapXFields::AddDateField(const VARIANT& Name)
  3183. {
  3184. LPDISPATCH result;
  3185. static BYTE parms[] =
  3186. VTS_VARIANT;
  3187. InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3188. &Name);
  3189. return CMapXField(result);
  3190. }
  3193. /////////////////////////////////////////////////////////////////////////////
  3194. // COleFont properties
  3196. CString COleFont::GetName()
  3197. {
  3198. CString result;
  3199. GetProperty(0x0, VT_BSTR, (void*)&result);
  3200. return result;
  3201. }
  3203. void COleFont::SetName(LPCTSTR propVal)
  3204. {
  3205. SetProperty(0x0, VT_BSTR, propVal);
  3206. }
  3208. CY COleFont::GetSize()
  3209. {
  3210. CY result;
  3211. GetProperty(0x2, VT_CY, (void*)&result);
  3212. return result;
  3213. }
  3215. void COleFont::SetSize(const CY& propVal)
  3216. {
  3217. SetProperty(0x2, VT_CY, &propVal);
  3218. }
  3220. BOOL COleFont::GetBold()
  3221. {
  3222. BOOL result;
  3223. GetProperty(0x3, VT_BOOL, (void*)&result);
  3224. return result;
  3225. }
  3227. void COleFont::SetBold(BOOL propVal)
  3228. {
  3229. SetProperty(0x3, VT_BOOL, propVal);
  3230. }
  3232. BOOL COleFont::GetItalic()
  3233. {
  3234. BOOL result;
  3235. GetProperty(0x4, VT_BOOL, (void*)&result);
  3236. return result;
  3237. }
  3239. void COleFont::SetItalic(BOOL propVal)
  3240. {
  3241. SetProperty(0x4, VT_BOOL, propVal);
  3242. }
  3244. BOOL COleFont::GetUnderline()
  3245. {
  3246. BOOL result;
  3247. GetProperty(0x5, VT_BOOL, (void*)&result);
  3248. return result;
  3249. }
  3251. void COleFont::SetUnderline(BOOL propVal)
  3252. {
  3253. SetProperty(0x5, VT_BOOL, propVal);
  3254. }
  3256. BOOL COleFont::GetStrikethrough()
  3257. {
  3258. BOOL result;
  3259. GetProperty(0x6, VT_BOOL, (void*)&result);
  3260. return result;
  3261. }
  3263. void COleFont::SetStrikethrough(BOOL propVal)
  3264. {
  3265. SetProperty(0x6, VT_BOOL, propVal);
  3266. }
  3268. short COleFont::GetWeight()
  3269. {
  3270. short result;
  3271. GetProperty(0x7, VT_I2, (void*)&result);
  3272. return result;
  3273. }
  3275. void COleFont::SetWeight(short propVal)
  3276. {
  3277. SetProperty(0x7, VT_I2, propVal);
  3278. }
  3280. short COleFont::GetCharset()
  3281. {
  3282. short result;
  3283. GetProperty(0x8, VT_I2, (void*)&result);
  3284. return result;
  3285. }
  3287. void COleFont::SetCharset(short propVal)
  3288. {
  3289. SetProperty(0x8, VT_I2, propVal);
  3290. }
  3292. /////////////////////////////////////////////////////////////////////////////
  3293. // COleFont operations
  3295. /////////////////////////////////////////////////////////////////////////////
  3296. // CMapXStyle properties
  3298. short CMapXStyle::GetSymbolCharacter()
  3299. {
  3300. short result;
  3301. GetProperty(0x1, VT_I2, (void*)&result);
  3302. return result;
  3303. }
  3305. void CMapXStyle::SetSymbolCharacter(short propVal)
  3306. {
  3307. SetProperty(0x1, VT_I2, propVal);
  3308. }
  3310. unsigned long CMapXStyle::GetLineColor()
  3311. {
  3312. unsigned long result;
  3313. GetProperty(0x2, VT_I4, (void*)&result);
  3314. return result;
  3315. }
  3317. void CMapXStyle::SetLineColor(unsigned long propVal)
  3318. {
  3319. SetProperty(0x2, VT_I4, propVal);
  3320. }
  3322. short CMapXStyle::GetLineStyle()
  3323. {
  3324. short result;
  3325. GetProperty(0x3, VT_I2, (void*)&result);
  3326. return result;
  3327. }
  3329. void CMapXStyle::SetLineStyle(short propVal)
  3330. {