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

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

GIS编程

开发平台：

Visual C++

MAPX.CPP：源码内容
  1. #include "stdafx.h"
  2. #include <afxconv.h>
  3. #include "mapx.h"
  5. /////////////////////////////////////////////////////////////////////////////
  6. // CMapX
  8. #ifdef CWND_MAPX
  9. IMPLEMENT_DYNCREATE(CMapX, CWnd)
  10. #endif
  12. /////////////////////////////////////////////////////////////////////////////
  13. // CMapX properties
  15. CString CMapX::GetDataSetGeoField()
  16. {
  17. CString result;
  18. GetProperty(0x1, VT_BSTR, (void*)&result);
  19. return result;
  20. }
  22. void CMapX::SetDataSetGeoField(LPCTSTR propVal)
  23. {
  24. SetProperty(0x1, VT_BSTR, propVal);
  25. }
  27. CString CMapX::GetVersion()
  28. {
  29. CString result;
  30. GetProperty(0x2, VT_BSTR, (void*)&result);
  31. return result;
  32. }
  34. OLE_HANDLE CMapX::GetHWnd()
  35. {
  36. OLE_HANDLE result;
  37. GetProperty(DISPID_HWND, VT_I4, (void*)&result);
  38. return result;
  39. }
  41. CMapXAnnotations CMapX::GetAnnotations()
  42. {
  43. LPDISPATCH result;
  44. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  45. return CMapXAnnotations(result);
  46. }
  48. CMapXLayers CMapX::GetLayers()
  49. {
  50. LPDISPATCH result;
  51. GetProperty(0x5, VT_DISPATCH, (void*)&result);
  52. return CMapXLayers(result);
  53. }
  55. BOOL CMapX::GetAutoRedraw()
  56. {
  57. BOOL result;
  58. GetProperty(0x6, VT_BOOL, (void*)&result);
  59. return result;
  60. }
  62. void CMapX::SetAutoRedraw(BOOL propVal)
  63. {
  64. SetProperty(0x6, VT_BOOL, propVal);
  65. }
  67. double CMapX::GetZoom()
  68. {
  69. double result;
  70. GetProperty(0x7, VT_R8, (void*)&result);
  71. return result;
  72. }
  74. void CMapX::SetZoom(double propVal)
  75. {
  76. SetProperty(0x7, VT_R8, propVal);
  77. }
  79. double CMapX::GetCenterX()
  80. {
  81. double result;
  82. GetProperty(0x8, VT_R8, (void*)&result);
  83. return result;
  84. }
  86. void CMapX::SetCenterX(double propVal)
  87. {
  88. SetProperty(0x8, VT_R8, propVal);
  89. }
  91. double CMapX::GetCenterY()
  92. {
  93. double result;
  94. GetProperty(0x9, VT_R8, (void*)&result);
  95. return result;
  96. }
  98. void CMapX::SetCenterY(double propVal)
  99. {
  100. SetProperty(0x9, VT_R8, propVal);
  101. }
  103. CString CMapX::GetGeoSet()
  104. {
  105. CString result;
  106. GetProperty(0xa, VT_BSTR, (void*)&result);
  107. return result;
  108. }
  110. void CMapX::SetGeoSet(LPCTSTR propVal)
  111. {
  112. SetProperty(0xa, VT_BSTR, propVal);
  113. }
  115. double CMapX::GetGeoSetWidth()
  116. {
  117. double result;
  118. GetProperty(0xb, VT_R8, (void*)&result);
  119. return result;
  120. }
  122. double CMapX::GetMapPaperHeight()
  123. {
  124. double result;
  125. GetProperty(0xc, VT_R8, (void*)&result);
  126. return result;
  127. }
  129. double CMapX::GetMapPaperWidth()
  130. {
  131. double result;
  132. GetProperty(0xd, VT_R8, (void*)&result);
  133. return result;
  134. }
  136. short CMapX::GetMaxSearchTime()
  137. {
  138. short result;
  139. GetProperty(0xe, VT_I2, (void*)&result);
  140. return result;
  141. }
  143. void CMapX::SetMaxSearchTime(short propVal)
  144. {
  145. SetProperty(0xe, VT_I2, propVal);
  146. }
  148. long CMapX::GetPaperUnit()
  149. {
  150. long result;
  151. GetProperty(0xf, VT_I4, (void*)&result);
  152. return result;
  153. }
  155. void CMapX::SetPaperUnit(long propVal)
  156. {
  157. SetProperty(0xf, VT_I4, propVal);
  158. }
  160. BOOL CMapX::GetPreferCompactLegends()
  161. {
  162. BOOL result;
  163. GetProperty(0x10, VT_BOOL, (void*)&result);
  164. return result;
  165. }
  167. void CMapX::SetPreferCompactLegends(BOOL propVal)
  168. {
  169. SetProperty(0x10, VT_BOOL, propVal);
  170. }
  172. CMapXStyle CMapX::GetDefaultStyle()
  173. {
  174. LPDISPATCH result;
  175. GetProperty(0x11, VT_DISPATCH, (void*)&result);
  176. return CMapXStyle(result);
  177. }
  179. void CMapX::SetDefaultStyle(LPDISPATCH propVal)
  180. {
  181. SetProperty(0x11, VT_DISPATCH, propVal);
  182. }
  184. CString CMapX::GetGeoDictionary()
  185. {
  186. CString result;
  187. GetProperty(0x12, VT_BSTR, (void*)&result);
  188. return result;
  189. }
  191. void CMapX::SetGeoDictionary(LPCTSTR propVal)
  192. {
  193. SetProperty(0x12, VT_BSTR, propVal);
  194. }
  196. long CMapX::GetDataSetTheme()
  197. {
  198. long result;
  199. GetProperty(0x13, VT_I4, (void*)&result);
  200. return result;
  201. }
  203. void CMapX::SetDataSetTheme(long propVal)
  204. {
  205. SetProperty(0x13, VT_I4, propVal);
  206. }
  208. long CMapX::GetCurrentTool()
  209. {
  210. long result;
  211. GetProperty(0x14, VT_I4, (void*)&result);
  212. return result;
  213. }
  215. void CMapX::SetCurrentTool(long propVal)
  216. {
  217. SetProperty(0x14, VT_I4, propVal);
  218. }
  220. long CMapX::GetMousePointer()
  221. {
  222. long result;
  223. GetProperty(0x15, VT_I4, (void*)&result);
  224. return result;
  225. }
  227. void CMapX::SetMousePointer(long propVal)
  228. {
  229. SetProperty(0x15, VT_I4, propVal);
  230. }
  232. CMapXDatasets CMapX::GetDatasets()
  233. {
  234. LPDISPATCH result;
  235. GetProperty(0x16, VT_DISPATCH, (void*)&result);
  236. return CMapXDatasets(result);
  237. }
  239. CMapXTitle CMapX::GetTitle()
  240. {
  241. LPDISPATCH result;
  242. GetProperty(0x17, VT_DISPATCH, (void*)&result);
  243. return CMapXTitle(result);
  244. }
  246. CString CMapX::GetTitleText()
  247. {
  248. CString result;
  249. GetProperty(0x18, VT_BSTR, (void*)&result);
  250. return result;
  251. }
  253. void CMapX::SetTitleText(LPCTSTR propVal)
  254. {
  255. SetProperty(0x18, VT_BSTR, propVal);
  256. }
  258. long CMapX::GetMapUnit()
  259. {
  260. long result;
  261. GetProperty(0x19, VT_I4, (void*)&result);
  262. return result;
  263. }
  265. void CMapX::SetMapUnit(long propVal)
  266. {
  267. SetProperty(0x19, VT_I4, propVal);
  268. }
  270. double CMapX::GetRotation()
  271. {
  272. double result;
  273. GetProperty(0x1a, VT_R8, (void*)&result);
  274. return result;
  275. }
  277. void CMapX::SetRotation(double propVal)
  278. {
  279. SetProperty(0x1a, VT_R8, propVal);
  280. }
  282. CMapXGeosets CMapX::GetGeosets()
  283. {
  284. LPDISPATCH result;
  285. GetProperty(0x1b, VT_DISPATCH, (void*)&result);
  286. return CMapXGeosets(result);
  287. }
  289. long CMapX::GetAreaUnit()
  290. {
  291. long result;
  292. GetProperty(0x1c, VT_I4, (void*)&result);
  293. return result;
  294. }
  296. void CMapX::SetAreaUnit(long propVal)
  297. {
  298. SetProperty(0x1c, VT_I4, propVal);
  299. }
  301. CMapXRectangle CMapX::GetBounds()
  302. {
  303. LPDISPATCH result;
  304. GetProperty(0x1d, VT_DISPATCH, (void*)&result);
  305. return CMapXRectangle(result);
  306. }
  308. void CMapX::SetBounds(LPDISPATCH propVal)
  309. {
  310. SetProperty(0x1d, VT_DISPATCH, propVal);
  311. }
  313. CMapXCoordSys CMapX::GetDisplayCoordSys()
  314. {
  315. LPDISPATCH result;
  316. GetProperty(0x1e, VT_DISPATCH, (void*)&result);
  317. return CMapXCoordSys(result);
  318. }
  320. void CMapX::SetDisplayCoordSys(LPDISPATCH propVal)
  321. {
  322. SetProperty(0x1e, VT_DISPATCH, propVal);
  323. }
  325. CMapXCoordSys CMapX::GetNumericCoordSys()
  326. {
  327. LPDISPATCH result;
  328. GetProperty(0x1f, VT_DISPATCH, (void*)&result);
  329. return CMapXCoordSys(result);
  330. }
  332. void CMapX::SetNumericCoordSys(LPDISPATCH propVal)
  333. {
  334. SetProperty(0x1f, VT_DISPATCH, propVal);
  335. }
  337. BOOL CMapX::GetExportSelection()
  338. {
  339. BOOL result;
  340. GetProperty(0x20, VT_BOOL, (void*)&result);
  341. return result;
  342. }
  344. void CMapX::SetExportSelection(BOOL propVal)
  345. {
  346. SetProperty(0x20, VT_BOOL, propVal);
  347. }
  349. CMapXStyle CMapX::GetSelectionStyle()
  350. {
  351. LPDISPATCH result;
  352. GetProperty(0x21, VT_DISPATCH, (void*)&result);
  353. return CMapXStyle(result);
  354. }
  356. void CMapX::SetSelectionStyle(LPDISPATCH propVal)
  357. {
  358. SetProperty(0x21, VT_DISPATCH, propVal);
  359. }
  361. CMapXFeatureFactory CMapX::GetFeatureFactory()
  362. {
  363. LPDISPATCH result;
  364. GetProperty(0x31, VT_DISPATCH, (void*)&result);
  365. return CMapXFeatureFactory(result);
  366. }
  368. long CMapX::GetDefaultConversionResolution()
  369. {
  370. long result;
  371. GetProperty(0x32, VT_I4, (void*)&result);
  372. return result;
  373. }
  375. void CMapX::SetDefaultConversionResolution(long propVal)
  376. {
  377. SetProperty(0x32, VT_I4, propVal);
  378. }
  380. OLE_COLOR CMapX::GetBackColor()
  381. {
  382. OLE_COLOR result;
  383. GetProperty(DISPID_BACKCOLOR, VT_I4, (void*)&result);
  384. return result;
  385. }
  387. void CMapX::SetBackColor(OLE_COLOR propVal)
  388. {
  389. SetProperty(DISPID_BACKCOLOR, VT_I4, propVal);
  390. }
  392. long CMapX::GetMousewheelSupport()
  393. {
  394. long result;
  395. GetProperty(0x33, VT_I4, (void*)&result);
  396. return result;
  397. }
  399. void CMapX::SetMousewheelSupport(long propVal)
  400. {
  401. SetProperty(0x33, VT_I4, propVal);
  402. }
  404. BOOL CMapX::GetMatchNumericFields()
  405. {
  406. BOOL result;
  407. GetProperty(0x34, VT_BOOL, (void*)&result);
  408. return result;
  409. }
  411. void CMapX::SetMatchNumericFields(BOOL propVal)
  412. {
  413. SetProperty(0x34, VT_BOOL, propVal);
  414. }
  416. double CMapX::GetMapScreenWidth()
  417. {
  418. double result;
  419. GetProperty(0x35, VT_R8, (void*)&result);
  420. return result;
  421. }
  423. double CMapX::GetMapScreenHeight()
  424. {
  425. double result;
  426. GetProperty(0x36, VT_R8, (void*)&result);
  427. return result;
  428. }
  430. long CMapX::GetRedrawInterval()
  431. {
  432.   long result;
  433. GetProperty(0x37, VT_I4, (void*)&result);
  434. return result;
  435. }
  437. void CMapX::SetRedrawInterval(long propVal)
  438. {
  439. SetProperty(0x37, VT_I4, propVal);
  440. }
  442. CString CMapX::GetSearchPath()
  443. {
  444. CString result;
  445. GetProperty(0x38, VT_BSTR, (void*)&result);
  446. return result;
  447. }
  449. void CMapX::SetSearchPath(LPCTSTR propVal)
  450. {
  451. SetProperty(0x38, VT_BSTR, propVal);
  452. }
  454. short CMapX::GetMatchThreshold()
  455. {
  456.   short result;
  457. GetProperty(0x39, VT_I2, (void*)&result);
  458. return result;
  459. }
  461. void CMapX::SetMatchThreshold(short propVal)
  462. {
  463. SetProperty(0x39, VT_I2, propVal);
  464. }
  466. BOOL CMapX::GetWaitCursorEnabled()
  467. {
  468.   BOOL result;
  469. GetProperty(0x3a, VT_BOOL, (void*)&result);
  470. return result;
  471. }
  473. void CMapX::SetWaitCursorEnabled(BOOL propVal)
  474. {
  475. SetProperty(0x3a, VT_BOOL, propVal);
  476. }
  478. BOOL CMapX::GetPanAnimationLayer()
  479. {
  480.   BOOL result;
  481. GetProperty(0x3c, VT_BOOL, (void*)&result);
  482. return result;
  483. }
  485. void CMapX::SetPanAnimationLayer(BOOL propVal)
  486. {
  487. SetProperty(0x3c, VT_BOOL, propVal);
  488. }
  490. long CMapX::GetInfotipPopupDelay()
  491. {
  492. long result;
  493. GetProperty(0x3d, VT_I4, (void*)&result);
  494. return result;
  495. }
  497. void CMapX::SetInfotipPopupDelay(long propVal)
  498. {
  499. SetProperty(0x3d, VT_I4, propVal);
  500. }
  502. CString CMapX::GetMouseIcon()
  503. {
  504. CString result;
  505. GetProperty(0x3e, VT_BSTR, (void*)&result);
  506. return result;
  507. }
  509. void CMapX::SetMouseIcon(LPCTSTR propVal)
  510. {
  511. SetProperty(0x3e, VT_BSTR, propVal);
  512. }
  514. BOOL CMapX::GetInfotipSupport()
  515. {
  516.   BOOL result;
  517. GetProperty(0x3f, VT_BOOL, (void*)&result);
  518. return result;
  519. }
  521. void CMapX::SetInfotipSupport(BOOL propVal)
  522. {
  523. SetProperty(0x3f, VT_BOOL, propVal);
  524. }
  526. short CMapX::GetFeatureEditMode()
  527. {
  528. short result;
  529. GetProperty(0x41, VT_I2, (void*)&result);
  530. return result;
  531. }
  533. void CMapX::SetFeatureEditMode(short propVal)
  534. {
  535. SetProperty(0x41, VT_I2, propVal);
  536. }
  538. long CMapX::GetCheckEscapeKeyInterval()
  539. {
  540. long result;
  541. GetProperty(0x43, VT_I4, (void*)&result);
  542. return result;
  543. }
  545. void CMapX::SetCheckEscapeKeyInterval(long propVal)
  546. {
  547. SetProperty(0x43, VT_I4, propVal);
  548. }
  550. /////////////////////////////////////////////////////////////////////////////
  551. // CMapX operations
  553. void CMapX::ConvertCoord(float* ScreenX, float* ScreenY, double* MapX, double* MapY, short Direction)
  554. {
  555. static BYTE parms[] =
  556. VTS_PR4 VTS_PR4 VTS_PR8 VTS_PR8 VTS_I2;
  557. InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  558.  ScreenX, ScreenY, MapX, MapY, Direction);
  559. }
  561. void CMapX::ZoomTo(double Zoom, double X, double Y)
  562. {
  563. static BYTE parms[] =
  564. VTS_R8 VTS_R8 VTS_R8;
  565. InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  566.  Zoom, X, Y);
  567. }
  569. void CMapX::CreateCustomTool(
  570. short ToolNumber, 
  571. short Type, 
  572. const VARIANT& Cursor, 
  573. const VARIANT& ShiftCursor, 
  574. const VARIANT& CtrlCursor, 
  575. const VARIANT& bInfoTips)
  576. {
  577. static BYTE parms[] =
  578. VTS_I2 VTS_I2 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  579. InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  580.  ToolNumber, Type, &Cursor, &CtrlCursor, &ShiftCursor, &bInfoTips);
  581. }
  583. double CMapX::Distance(double X1, double Y1, double X2, double Y2)
  584. {
  585. double result;
  586. static BYTE parms[] =
  587. VTS_R8 VTS_R8 VTS_R8 VTS_R8;
  588. InvokeHelper(0x25, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
  589. X1, Y1, X2, Y2);
  590. return result;
  591. }
  593. void CMapX::Refresh()
  594. {
  595. InvokeHelper(DISPID_REFRESH, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  596. }
  598. void CMapX::PrintMap(long hDC, long X, long Y, long W, long H)
  599. {
  600. static BYTE parms[] =
  601. VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  602. InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  603.  hDC, X, Y, W, H);
  604. }
  606. void CMapX::ExportMap(LPCTSTR Destination, short Format, const VARIANT& Width, const VARIANT& Height)
  607. {
  608. static BYTE parms[] =
  609. VTS_BSTR VTS_I2 VTS_VARIANT VTS_VARIANT;
  610. InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  611.  Destination, Format, &Width, &Height);
  612. }
  614. void CMapX::PropertyPage()
  615. {
  616. InvokeHelper(0x28, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  617. }
  619. void CMapX::ConvertCoordV(VARIANT* ScreenX, VARIANT* ScreenY, VARIANT* MapX, VARIANT* MapY, short Direction)
  620. {
  621. static BYTE parms[] =
  622. VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_I2;
  623. InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  624.  ScreenX, ScreenY, MapX, MapY, Direction);
  625. }
  627. void CMapX::SetSize(long Width, long Height)
  628. {
  629. static BYTE parms[] =
  630. VTS_I4 VTS_I4;
  631. InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  632.  Width, Height);
  633. }
  635. BOOL CMapX::IsPointVisible(double X, double Y)
  636. {
  637. BOOL result;
  638. static BYTE parms[] =
  639. VTS_R8 VTS_R8;
  640. InvokeHelper(0x2b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  641. X, Y);
  642. return result;
  643. }
  645. BOOL CMapX::ClipLine(double* X1, double* Y1, double* X2, double* Y2)
  646. {
  647. BOOL result;
  648. static BYTE parms[] =
  649. VTS_PR8 VTS_PR8 VTS_PR8 VTS_PR8;
  650. InvokeHelper(0x2c, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  651. X1, Y1, X2, Y2);
  652. return result;
  653. }
  655. BOOL CMapX::ClipLineV(VARIANT* X1, VARIANT* Y1, VARIANT* X2, VARIANT* Y2)
  656. {
  657. BOOL result;
  658. static BYTE parms[] =
  659. VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
  660. InvokeHelper(0x2d, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  661. X1, Y1, X2, Y2);
  662. return result;
  663. }
  665. void CMapX::AboutBox()
  666. {
  667. InvokeHelper(0xfffffdd8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  668. }
  670. void CMapX::SaveMapAsGeoset(LPCTSTR Name, LPCTSTR Filespec)
  671. {
  672. static BYTE parms[] =
  673. VTS_BSTR VTS_BSTR;
  674. InvokeHelper(0x2f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  675. Name, Filespec);
  676. }
  678. LPDISPATCH CMapX::GetDispatch(BOOL bAddRef)
  679. {
  680. #ifdef CWND_MAPX
  681. LPUNKNOWN pUnk = GetControlUnknown();
  682. #else
  683. LPUNKNOWN pUnk = m_lpDispatch;
  684. #endif
  685. LPDISPATCH pDispatch;
  687. if ((pUnk != NULL) && SUCCEEDED(pUnk->QueryInterface(IID_IDispatch, (LPVOID*)&pDispatch))) {
  688. ASSERT(pDispatch != NULL);
  689. if (!bAddRef) {
  690. pDispatch->Release();
  691. }
  692. return pDispatch;
  693. }
  694. return NULL;
  695. }
  697. void CMapX::Pan(float ScreenX, float ScreenY)
  698. {
  699. static BYTE parms[] =
  700. VTS_R4 VTS_R4;
  701. InvokeHelper(0x40, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  702.  ScreenX, ScreenY);
  703. }
  705. /////////////////////////////////////////////////////////////////////////////
  706. // CMapXDatasets properties
  708. LPENUMVARIANT CMapXDatasets::GetEnumerator()
  709. {
  710. LPENUMVARIANT pEnumVariant = 0;
  711. LPUNKNOWN pUnknown = 0;
  712. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  713. if(pUnknown)
  714. {
  715. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  716. pUnknown->Release();
  717. }
  718. return pEnumVariant;
  719. }
  721. long CMapXDatasets::GetCount()
  722. {
  723. long result;
  724. GetProperty(0x1, VT_I4, (void*)&result);
  725. return result;
  726. }
  728. BOOL CMapXDatasets::GetBuildSourceRows()
  729. {
  730.   BOOL result;
  731. GetProperty(0x7, VT_BOOL, &result);
  732. return result;
  733. }
  735. void CMapXDatasets::SetBuildSourceRows(BOOL b)
  736. {
  737. SetProperty(0x7, VT_BOOL, b);
  738. }
  740. /////////////////////////////////////////////////////////////////////////////
  741. // CMapXDatasets operations
  743. 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)
  744. {
  745. LPDISPATCH result;
  746. static BYTE parms[] =
  747. VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  748. InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  749. Type, &SourceData, &Name, &GeoField, &SecondaryGeoField, &BindLayer, &Fields, &Dynamic);
  750. return CMapXDataset(result);
  751. }
  753. CMapXDataset CMapXDatasets::Item(const VARIANT& Index)
  754. {
  755. LPDISPATCH result;
  756. static BYTE parms[] =
  757. VTS_VARIANT;
  758. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  759. &Index);
  760. return CMapXDataset(result);
  761. }
  763. void CMapXDatasets::Remove(const VARIANT& Index)
  764. {
  765. static BYTE parms[] =
  766. VTS_VARIANT;
  767. InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  768.  &Index);
  769. }
  771. CMapXDataset CMapXDatasets::Restore(LPCTSTR Name, const VARIANT& SourceData)
  772. {
  773. LPDISPATCH result;
  774. static BYTE parms[] =
  775. VTS_BSTR VTS_VARIANT;
  776. InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  777. Name, &SourceData);
  778. return CMapXDataset(result);
  779. }
  781. void CMapXDatasets::RemoveAll()
  782. {
  783. InvokeHelper(0x6, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  784. }
  786. /////////////////////////////////////////////////////////////////////////////
  787. // CMapXLayers properties
  789. LPENUMVARIANT CMapXLayers::GetEnumerator()
  790. {
  791. LPENUMVARIANT pEnumVariant = 0;
  792. LPUNKNOWN pUnknown = 0;
  793. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  794. if(pUnknown)
  795. {
  796. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  797. pUnknown->Release();
  798. }
  799. return pEnumVariant;
  800. }
  802. long CMapXLayers::GetCount()
  803. {
  804. long result;
  805. GetProperty(0x1, VT_I4, (void*)&result);
  806. return result;
  807. }
  809. CMapXRectangle CMapXLayers::GetClippedBounds()
  810. {
  811. LPDISPATCH result;
  812. GetProperty(0x10, VT_DISPATCH, (void*)&result);
  813. return CMapXRectangle(result);
  814. }
  816. /////////////////////////////////////////////////////////////////////////////
  817. // CMapXLayers operations
  819. void CMapXLayers::ClearSelection()
  820. {
  821. InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  822. }
  824. BOOL CMapXLayers::Move(short From, short To)
  825. {
  826. BOOL result;
  827. static BYTE parms[] =
  828. VTS_I2 VTS_I2;
  829. InvokeHelper(0x3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  830. From, To);
  831. return result;
  832. }
  834. CMapXLayer CMapXLayers::Add(const VARIANT& LayerInfo, const VARIANT& Position)
  835. {
  836. LPDISPATCH result;
  837. static BYTE parms[] =
  838. VTS_VARIANT VTS_VARIANT;
  839. InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  840. &LayerInfo, &Position);
  841. return CMapXLayer(result);
  842. }
  844. void CMapXLayers::AddGeoSetLayers(LPCTSTR GeoSetName)
  845. {
  846. static BYTE parms[] =
  847. VTS_BSTR;
  848. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  849.  GeoSetName);
  850. }
  852. CMapXLayer CMapXLayers::Item(const VARIANT& Index)
  853. {
  854. LPDISPATCH result;
  855. static BYTE parms[] =
  856. VTS_VARIANT;
  857. InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  858. &Index);
  859. return CMapXLayer(result);
  860. }
  862. void CMapXLayers::Remove(const VARIANT& Index)
  863. {
  864. static BYTE parms[] =
  865. VTS_VARIANT;
  866. InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  867.  &Index);
  868. }
  870. CMapXLayer CMapXLayers::AddUserDrawLayer(LPCTSTR Name, short Position)
  871. {
  872. LPDISPATCH result;
  873. static BYTE parms[] =
  874. VTS_BSTR VTS_I2;
  875. InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  876. Name, Position);
  877. return CMapXLayer(result);
  878. }
  880. CMapXLayer CMapXLayers::GetAnimationLayer()
  881. {
  882. LPDISPATCH result;
  883. GetProperty(0x9, VT_DISPATCH, (void*)&result);
  884. return CMapXLayer(result);
  885. }
  887. void CMapXLayers::SetAnimationLayer(LPDISPATCH propVal)
  888. {
  889. SetProperty(0x9, VT_DISPATCH, propVal);
  890. }
  892. CMapXRectangle CMapXLayers::GetBounds()
  893. {
  894. LPDISPATCH result;
  895. GetProperty(0xc, VT_DISPATCH, (void*)&result);
  896. return CMapXRectangle(result);
  897. }
  899. CMapXLayer CMapXLayers::CreateLayer(LPCTSTR Name, const VARIANT& Filespec, const VARIANT& Position, const VARIANT& KeyLength, const VARIANT& CoordSys)
  900. {
  901. LPDISPATCH result;
  902. static BYTE parms[] =
  903. VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  904. InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  905. Name, &Filespec, &Position, &KeyLength, &CoordSys);
  906. return CMapXLayer(result);
  907. }
  909. BOOL CMapXLayers::LayersDlg(const VARIANT& HelpFile, const VARIANT& HelpID)
  910. {
  911. BOOL result;
  912. static BYTE parms[] =
  913. VTS_VARIANT VTS_VARIANT;
  914. InvokeHelper(0xb, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  915. &HelpFile, &HelpID);
  916. return result;
  917. }
  919. CMapXLayer CMapXLayers::AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query, const VARIANT& Position, const VARIANT& Options)
  920. {
  921. LPDISPATCH result;
  922. static BYTE parms[] =
  923. VTS_BSTR VTS_BSTR VTS_BSTR VTS_VARIANT VTS_VARIANT;
  924. InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  925. Name, ConnectString, Query, &Position, &Options);
  926. return CMapXLayer(result);
  927. }
  929. void CMapXLayers::RemoveAll()
  930. {
  931. InvokeHelper(0xe, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  932. }
  935. CMapXLayer CMapXLayers::GetInsertionLayer()
  936. {
  937. LPDISPATCH pDispatch;
  938. GetProperty(0xf, VT_DISPATCH, (void*)&pDispatch);
  939. return CMapXLayer(pDispatch);
  940. }
  942. void CMapXLayers::SetInsertionLayer(LPDISPATCH propVal)
  943. {
  944. SetProperty(0xf, VT_DISPATCH, propVal);
  945. }
  947. /////////////////////////////////////////////////////////////////////////////
  948. // CMapXLayer properties
  950. CString CMapXLayer::GetName()
  951. {
  952. CString result;
  953. GetProperty(0x1, VT_BSTR, (void*)&result);
  954. return result;
  955. }
  957. void CMapXLayer::SetName(LPCTSTR propVal)
  958. {
  959. SetProperty(0x1, VT_BSTR, propVal);
  960. }
  962. BOOL CMapXLayer::GetVisible()
  963. {
  964. BOOL result;
  965. GetProperty(0x2, VT_BOOL, (void*)&result);
  966. return result;
  967. }
  969. void CMapXLayer::SetVisible(BOOL propVal)
  970. {
  971. SetProperty(0x2, VT_BOOL, propVal);
  972. }
  974. BOOL CMapXLayer::GetSelectable()
  975. {
  976. BOOL result;
  977. GetProperty(0x3, VT_BOOL, (void*)&result);
  978. return result;
  979. }
  981. void CMapXLayer::SetSelectable(BOOL propVal)
  982. {
  983. SetProperty(0x3, VT_BOOL, propVal);
  984. }
  986. CString CMapXLayer::GetFilespec()
  987. {
  988. CString result;
  989. GetProperty(0x4, VT_BSTR, (void*)&result);
  990. return result;
  991. }
  993. CMapXLabelProperties CMapXLayer::GetLabelProperties()
  994. {
  995. LPDISPATCH result;
  996. GetProperty(0x5, VT_DISPATCH, (void*)&result);
  997. return CMapXLabelProperties(result);
  998. }
  1000. BOOL CMapXLayer::GetAutoLabel()
  1001. {
  1002. BOOL result;
  1003. GetProperty(0x6, VT_BOOL, (void*)&result);
  1004. return result;
  1005. }
  1007. void CMapXLayer::SetAutoLabel(BOOL propVal)
  1008. {
  1009. SetProperty(0x6, VT_BOOL, propVal);
  1010. }
  1012. BOOL CMapXLayer::GetZoomLayer()
  1013. {
  1014. BOOL result;
  1015. GetProperty(0x7, VT_BOOL, (void*)&result);
  1016. return result;
  1017. }
  1019. void CMapXLayer::SetZoomLayer(BOOL propVal)
  1020. {
  1021. SetProperty(0x7, VT_BOOL, propVal);
  1022. }
  1024. BOOL CMapXLayer::GetOverrideStyle()
  1025. {
  1026. BOOL result;
  1027. GetProperty(0x8, VT_BOOL, (void*)&result);
  1028. return result;
  1029. }
  1031. void CMapXLayer::SetOverrideStyle(BOOL propVal)
  1032. {
  1033. SetProperty(0x8, VT_BOOL, propVal);
  1034. }
  1036. CMapXStyle CMapXLayer::GetStyle()
  1037. {
  1038. LPDISPATCH result;
  1039. GetProperty(0x9, VT_DISPATCH, (void*)&result);
  1040. return CMapXStyle(result);
  1041. }
  1043. void CMapXLayer::SetStyle(LPDISPATCH propVal)
  1044. {
  1045. SetProperty(0x9, VT_DISPATCH, propVal);
  1046. }
  1048. double CMapXLayer::GetZoomMin()
  1049. {
  1050. double result;
  1051. GetProperty(0xa, VT_R8, (void*)&result);
  1052. return result;
  1053. }
  1055. void CMapXLayer::SetZoomMin(double propVal)
  1056. {
  1057. SetProperty(0xa, VT_R8, propVal);
  1058. }
  1060. double CMapXLayer::GetZoomMax()
  1061. {
  1062. double result;
  1063. GetProperty(0xb, VT_R8, (void*)&result);
  1064. return result;
  1065. }
  1067. void CMapXLayer::SetZoomMax(double propVal)
  1068. {
  1069. SetProperty(0xb, VT_R8, propVal);
  1070. }
  1072. CMapXSelection CMapXLayer::GetSelection()
  1073. {
  1074. LPDISPATCH result;
  1075. GetProperty(0xc, VT_DISPATCH, (void*)&result);
  1076. return CMapXSelection(result);
  1077. }
  1079. short CMapXLayer::GetPredominantFeatureType()
  1080. {
  1081. short result;
  1082. GetProperty(0xd, VT_I2, (void*)&result);
  1083. return result;
  1084. }
  1086. CMapXLayerFind CMapXLayer::GetFind()
  1087. {
  1088. LPDISPATCH result;
  1089. GetProperty(0xe, VT_DISPATCH, (void*)&result);
  1090. return CMapXLayerFind(result);
  1091. }
  1093. short CMapXLayer::GetType()
  1094. {
  1095. short result;
  1096. GetProperty(0xf, VT_I2, (void*)&result);
  1097. return result;
  1098. }
  1100. CString CMapXLayer::GetKeyField()
  1101. {
  1102. CString result;
  1103. GetProperty(0x10, VT_BSTR, (void*)&result);
  1104. return result;
  1105. }
  1107. void CMapXLayer::SetKeyField(LPCTSTR propVal)
  1108. {
  1109. SetProperty(0x10, VT_BSTR, propVal);
  1110. }
  1112. CMapXCoordSys CMapXLayer::GetCoordSys()
  1113. {
  1114. LPDISPATCH result;
  1115. GetProperty(0x11, VT_DISPATCH, (void*)&result);
  1116. return CMapXCoordSys(result);
  1117. }
  1119. CMapXRectangle CMapXLayer::GetBounds()
  1120. {
  1121. LPDISPATCH result;
  1122. GetProperty(0x20, VT_DISPATCH, (void*)&result);
  1123. return CMapXRectangle(result);
  1124. }
  1126. BOOL CMapXLayer::GetDrawLabelsAfter()
  1127. {
  1128. BOOL result;
  1129. GetProperty(0x25, VT_BOOL, (void*)&result);
  1130. return result;
  1131. }
  1133. void CMapXLayer::SetDrawLabelsAfter(BOOL propVal)
  1134. {
  1135. SetProperty(0x25, VT_BOOL, propVal);
  1136. }
  1138. CMapXDatasets CMapXLayer::GetDatasets()
  1139. {
  1140. LPDISPATCH result;
  1141. GetProperty(0x27, VT_DISPATCH, (void*)&result);
  1142. return CMapXDatasets(result);
  1143. }
  1145. BOOL CMapXLayer::GetShowNodes()
  1146. {
  1147. BOOL result;
  1148. GetProperty(0x2b, VT_BOOL, (void*)&result);
  1149. return result;
  1150. }
  1152. void CMapXLayer::SetShowNodes(BOOL propVal)
  1153. {
  1154. SetProperty(0x2b, VT_BOOL, propVal);
  1155. }
  1157. BOOL CMapXLayer::GetShowCentroids()
  1158. {
  1159. BOOL result;
  1160. GetProperty(0x2c, VT_BOOL, (void*)&result);
  1161. return result;
  1162. }
  1164. void CMapXLayer::SetShowCentroids(BOOL propVal)
  1165. {
  1166. SetProperty(0x2c, VT_BOOL, propVal);
  1167. }
  1169. BOOL CMapXLayer::GetShowLineDirection()
  1170. {
  1171. BOOL result;
  1172. GetProperty(0x2d, VT_BOOL, (void*)&result);
  1173. return result;
  1174. }
  1176. void CMapXLayer::SetShowLineDirection(BOOL propVal)
  1177. {
  1178. SetProperty(0x2d, VT_BOOL, propVal);
  1179. }
  1181. BOOL CMapXLayer::GetEditable()
  1182. {
  1183. BOOL result;
  1184. GetProperty(0x2e, VT_BOOL, (void*)&result);
  1185. return result;
  1186. }
  1188. void CMapXLayer::SetEditable(BOOL propVal)
  1189. {
  1190. SetProperty(0x2e, VT_BOOL, propVal);
  1191. }
  1193. CMapXRectangle CMapXLayer::GetClippedBounds()
  1194. {
  1195. LPDISPATCH result;
  1196. GetProperty(0x31, VT_DISPATCH, (void*)&result);
  1197. return CMapXRectangle(result);
  1198. }
  1200. /////////////////////////////////////////////////////////////////////////////
  1201. // CMapXLayer operations
  1203. void CMapXLayer::LabelAtPoint(double X, double Y)
  1204. {
  1205. static BYTE parms[] =
  1206. VTS_R8 VTS_R8;
  1207. InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1208.  X, Y);
  1209. }
  1211. void CMapXLayer::ClearCustomLabels()
  1212. {
  1213. InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1214. }
  1216. CMapXFeature CMapXLayer::AddFeature(LPDISPATCH Source, const VARIANT& RowValues)
  1217. {
  1218. LPDISPATCH result;
  1219. static BYTE parms[] =
  1220. VTS_DISPATCH VTS_VARIANT;
  1221. InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1222. Source, &RowValues);
  1223. return CMapXFeature(result);
  1224. }
  1226. void CMapXLayer::UpdateFeature(
  1227. const VARIANT& Target, 
  1228. const VARIANT& Source,
  1229. const VARIANT& RowValues)
  1230. {
  1231. static BYTE parms[] =
  1232. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1233. InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1234.  &Target, &Source, &RowValues);
  1235. }
  1237. void CMapXLayer::DeleteFeature(const VARIANT& Target)
  1238. {
  1239. static BYTE parms[] = VTS_VARIANT;
  1240. InvokeHelper(0x16, DISPATCH_METHOD, VT_EMPTY, NULL, parms, &Target);
  1241. }
  1243. void CMapXLayer::Invalidate(const VARIANT& InvalidRect)
  1244. {
  1245. static BYTE parms[] =
  1246. VTS_VARIANT;
  1247. InvokeHelper(0x17, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1248.  &InvalidRect);
  1249. }
  1251. CMapXFeatures CMapXLayer::SearchWithinDistance(LPDISPATCH Source, double Distance, short Units, short SearchType)
  1252. {
  1253. LPDISPATCH result;
  1254. static BYTE parms[] =
  1255. VTS_DISPATCH VTS_R8 VTS_I2 VTS_I2;
  1256. InvokeHelper(0x18, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1257. Source, Distance, Units, SearchType);
  1258. return CMapXFeatures(result);
  1259. }
  1261. CMapXFeatures CMapXLayer::SearchWithinRectangle(LPDISPATCH Rectangle, short SearchType)
  1262. {
  1263. LPDISPATCH result;
  1264. static BYTE parms[] =
  1265. VTS_DISPATCH VTS_I2;
  1266. InvokeHelper(0x19, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1267. Rectangle, SearchType);
  1268. return CMapXFeatures(result);
  1269. }
  1271. CMapXFeatures CMapXLayer::AllFeatures()
  1272. {
  1273. LPDISPATCH result;
  1274. InvokeHelper(0x1a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  1275. return CMapXFeatures(result);
  1276. }
  1278. CMapXFeatures CMapXLayer::NoFeatures()
  1279. {
  1280. LPDISPATCH result;
  1281. InvokeHelper(0x1b, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  1282. return CMapXFeatures(result);
  1283. }
  1285. CMapXFeatures CMapXLayer::SearchWithinFeature(LPDISPATCH Feature, short SearchType)
  1286. {
  1287. LPDISPATCH result;
  1288. static BYTE parms[] =
  1289. VTS_DISPATCH VTS_I2;
  1290. InvokeHelper(0x1c, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1291. Feature, SearchType);
  1292. return CMapXFeatures(result);
  1293. }
  1295. CMapXFeatures CMapXLayer::SearchAtPoint(LPDISPATCH Point, short SearchResultFlags)
  1296. {
  1297. LPDISPATCH result;
  1298. static BYTE parms[] =
  1299. VTS_DISPATCH VTS_I2;
  1300. InvokeHelper(0x1d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1301. Point, SearchResultFlags);
  1302. return CMapXFeatures(result);
  1303. }
  1305. void CMapXLayer::DrillDownRemoveFeatures(LPCTSTR Level, const VARIANT& FeatureKeys)
  1306. {
  1307. static BYTE parms[] =
  1308. VTS_BSTR VTS_VARIANT;
  1309. InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1310.  Level, &FeatureKeys);
  1311. }
  1313. void CMapXLayer::DrillDownAddFeatures(LPCTSTR Level, const VARIANT& FeatureKeys)
  1314. {
  1315. static BYTE parms[] =
  1316. VTS_BSTR VTS_VARIANT;
  1317. InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1318.  Level, &FeatureKeys);
  1319. }
  1321. CMapXFeatures CMapXLayer::GetDrilldownFeaturesByID(LPCTSTR Level, const VARIANT& FeatureKeys)
  1322. {
  1323. LPDISPATCH result;
  1324. static BYTE parms[] =
  1325. VTS_BSTR VTS_VARIANT;
  1326. InvokeHelper(0x21, DISPATCH_METHOD, VT_DISPATCH, (void *)&result, parms,
  1327.  Level, &FeatureKeys);
  1328. return CMapXFeatures(result);
  1329. }
  1331. void CMapXLayer::DrilldownReset(LPCTSTR Level)
  1332. {
  1333. static BYTE parms[] =
  1334. VTS_BSTR;
  1335. InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1336.  Level);
  1337. }
  1339. CMapXFeature CMapXLayer::GetFeatureByID(long FeatureID)
  1340. {
  1341. LPDISPATCH result;
  1342. static BYTE parms[] =
  1343. VTS_I4;
  1344. InvokeHelper(0x23, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1345. FeatureID);
  1346. return CMapXFeature(result);
  1347. }
  1349. void CMapXLayer::Refresh()
  1350. {
  1351. InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1352. }
  1354. long CMapXLayer::FeatureIDFromFeatureName(LPCTSTR Name)
  1355. {
  1356. long result;
  1357. static BYTE parms[] =
  1358. VTS_BSTR;
  1359. InvokeHelper(0x26, DISPATCH_METHOD, VT_I4, &result, parms, Name);
  1360. return result;
  1361. }
  1363. CMapXFeatures CMapXLayer::Search(LPCTSTR strWhere, const VARIANT& Variables)
  1364. {
  1365. LPDISPATCH result;
  1366. static BYTE parms[] = VTS_BSTR VTS_VARIANT;
  1367. InvokeHelper(0x28, DISPATCH_METHOD, VT_DISPATCH, (void *)&result, parms, strWhere, &Variables);
  1368. return CMapXFeatures(result);
  1369. }
  1371. void CMapXLayer::BeginAccess(long BeginAccessType)
  1372. {
  1373. static BYTE parms[] = VTS_I2;
  1374. InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms, BeginAccessType);
  1375. }
  1377. void CMapXLayer::EndAccess(const VARIANT& EndAccessType)
  1378. {
  1379. static BYTE parms[] = VTS_VARIANT;
  1380. InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms, &EndAccessType);
  1381. }
  1383. CMapXFeature CMapXLayer::GetFeatureByKey(LPCTSTR FeatureKey)
  1384. {
  1385. LPDISPATCH result;
  1386. static BYTE parms[] = VTS_BSTR;
  1387. InvokeHelper(0x2f, DISPATCH_METHOD, VT_DISPATCH, (void *)&result, parms, FeatureKey);
  1388. return CMapXFeature(result);
  1389. }
  1391. CString CMapXLayer::FeatureKeyFromFeatureName(LPCTSTR strKeyValue)
  1392. {
  1393. CString result;
  1394. static BYTE parms[] = VTS_BSTR;
  1395. InvokeHelper(0x30, DISPATCH_METHOD, VT_BSTR, (void *)&result, parms, strKeyValue);
  1396. return result;
  1397. }
  1399. /////////////////////////////////////////////////////////////////////////////
  1400. // CMapXField properties
  1402. long CMapXField::GetType()
  1403. {
  1404. long result;
  1405. GetProperty(0x1, VT_I4, (void*)&result);
  1406. return result;
  1407. }
  1409. CString CMapXField::GetName()
  1410. {
  1411. CString result;
  1412. GetProperty(0x2, VT_BSTR, (void*)&result);
  1413. return result;
  1414. }
  1416. long CMapXField::GetAggregationFunction()
  1417. {
  1418. long result;
  1419. GetProperty(0x3, VT_I4, (void*)&result);
  1420. return result;
  1421. }
  1423. short CMapXField::GetWidth()
  1424. {
  1425. short result;
  1426. GetProperty(0x4, VT_I2, (void*)&result);
  1427. return result;
  1428. }
  1430. short CMapXField::GetPrecision()
  1431. {
  1432. short result;
  1433. GetProperty(0x5, VT_I2, (void*)&result);
  1434. return result;
  1435. }
  1437. short CMapXField::GetDecimals()
  1438. {
  1439. short result;
  1440. GetProperty(0x6, VT_I2, (void*)&result);
  1441. return result;
  1442. }
  1444. BOOL CMapXField::GetIndexed()
  1445. {
  1446. BOOL result;
  1447. GetProperty(0x7, VT_BOOL, (void*)&result);
  1448. return result;
  1449. }
  1451. long CMapXField::GetTypeEx()
  1452. {
  1453. long result;
  1454. GetProperty(0x8, VT_I4, (void*)&result);
  1455. return result;
  1456. }
  1458. /////////////////////////////////////////////////////////////////////////////
  1459. // CMapXField operations
  1462. /////////////////////////////////////////////////////////////////////////////
  1463. // CMapXDataset properties
  1465. CString CMapXDataset::GetName()
  1466. {
  1467. CString result;
  1468. GetProperty(0x1, VT_BSTR, (void*)&result);
  1469. return result;
  1470. }
  1472. void CMapXDataset::SetName(LPCTSTR propVal)
  1473. {
  1474. SetProperty(0x1, VT_BSTR, propVal);
  1475. }
  1477. long CMapXDataset::GetRowCount()
  1478. {
  1479. long result;
  1480. GetProperty(0x2, VT_I4, (void*)&result);
  1481. return result;
  1482. }
  1484. CMapXFields CMapXDataset::GetFields()
  1485. {
  1486. LPDISPATCH result;
  1487. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  1488. return CMapXFields(result);
  1489. }
  1491. CMapXThemes CMapXDataset::GetThemes()
  1492. {
  1493. LPDISPATCH result;
  1494. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  1495. return CMapXThemes(result);
  1496. }
  1498. long CMapXDataset::GetGeoField()
  1499. {
  1500. long result;
  1501. GetProperty(0x5, VT_I4, (void*)&result);
  1502. return result;
  1503. }
  1505. long CMapXDataset::GetSecondaryGeoField()
  1506. {
  1507. long result;
  1508. GetProperty(0x6, VT_I4, (void*)&result);
  1509. return result;
  1510. }
  1512. CMapXLayer CMapXDataset::GetLayer()
  1513. {
  1514. LPDISPATCH result;
  1515. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  1516. return CMapXLayer(result);
  1517. }
  1519. short CMapXDataset::GetType()
  1520. {
  1521. short result;
  1522. GetProperty(0xb, VT_I2, (void*)&result);
  1523. return result;
  1524. }
  1526. BOOL CMapXDataset::GetReadOnly()
  1527. {
  1528. BOOL result;
  1529. GetProperty(0xc, VT_BOOL, (void*)&result);
  1530. return result;
  1531. }
  1533. /////////////////////////////////////////////////////////////////////////////
  1534. // CMapXDataset operations
  1536. void CMapXDataset::Refresh()
  1537. {
  1538. InvokeHelper(0x8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1539. }
  1541. VARIANT CMapXDataset::GetValue(const VARIANT& Row, const VARIANT& Column)
  1542. {
  1543. VARIANT result;
  1544. static BYTE parms[] =
  1545. VTS_VARIANT VTS_VARIANT;
  1546. InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
  1547. &Row, &Column);
  1548. return result;
  1549. }
  1551. CMapXSourceRows CMapXDataset::GetSourceRows(const VARIANT& Row)
  1552. {
  1553. LPDISPATCH result;
  1554. static BYTE parms[] =
  1555. VTS_VARIANT;
  1556. InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  1557. &Row);
  1558. return CMapXSourceRows(result);
  1559. }
  1561. CMapXRowValues CMapXDataset::GetRowValues(const VARIANT& Row)
  1562. {
  1563. LPDISPATCH result;
  1564. static BYTE parms[] =
  1565. VTS_VARIANT;
  1566. InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms, &Row);
  1567. return CMapXRowValues(result);
  1568. }
  1570. CMapXField CMapXDataset::AddField(LPCTSTR Name, LPCTSTR Expression)
  1571. {
  1572. LPDISPATCH result;
  1573. static BYTE parms[] = VTS_BSTR VTS_BSTR;
  1574. InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms, Name, Expression);
  1575. return CMapXField(result);
  1576. }
  1578. /////////////////////////////////////////////////////////////////////////////
  1579. // CMapXThemes properties
  1581. LPENUMVARIANT CMapXThemes::GetEnumerator()
  1582. {
  1583. LPENUMVARIANT pEnumVariant = 0;
  1584. LPUNKNOWN pUnknown = 0;
  1585. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  1586. if(pUnknown)
  1587. {
  1588. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  1589. pUnknown->Release();
  1590. }
  1591. return pEnumVariant;
  1592. }
  1594. long CMapXThemes::GetCount()
  1595. {
  1596. long result;
  1597. GetProperty(0x1, VT_I4, (void*)&result);
  1598. return result;
  1599. }
  1601. /////////////////////////////////////////////////////////////////////////////
  1602. // CMapXThemes operations
  1604. CMapXTheme CMapXThemes::Add(const VARIANT& Type, const VARIANT& Field, const VARIANT& Name, const VARIANT& ComputeTheme)
  1605. {
  1606. LPDISPATCH result;
  1607. static BYTE parms[] =
  1608. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1609. InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1610. &Type, &Field, &Name, &ComputeTheme);
  1611. return CMapXTheme(result);
  1612. }
  1614. CMapXTheme CMapXThemes::Item(const VARIANT& Index)
  1615. {
  1616. LPDISPATCH result;
  1617. static BYTE parms[] =
  1618. VTS_VARIANT;
  1619. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1620. &Index);
  1621. return CMapXTheme(result);
  1622. }
  1624. void CMapXThemes::Remove(const VARIANT& Index)
  1625. {
  1626. static BYTE parms[] =
  1627. VTS_VARIANT;
  1628. InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1629.  &Index);
  1630. }
  1632. void CMapXThemes::RemoveAll()
  1633. {
  1634. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1635. }
  1637. /////////////////////////////////////////////////////////////////////////////
  1638. // CMapXTheme properties
  1640. BOOL CMapXTheme::GetVisible()
  1641. {
  1642. BOOL result;
  1643. GetProperty(0x1, VT_BOOL, (void*)&result);
  1644. return result;
  1645. }
  1647. void CMapXTheme::SetVisible(BOOL propVal)
  1648. {
  1649. SetProperty(0x1, VT_BOOL, propVal);
  1650. }
  1652. short CMapXTheme::GetType()
  1653. {
  1654. short result;
  1655. GetProperty(0x2, VT_I2, (void*)&result);
  1656. return result;
  1657. }
  1659. CMapXThemeProperties CMapXTheme::GetProperties()
  1660. {
  1661. LPDISPATCH result;
  1662. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  1663. return CMapXThemeProperties(result);
  1664. }
  1666. CMapXLegend CMapXTheme::GetLegend()
  1667. {
  1668. LPDISPATCH result;
  1669. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  1670. return CMapXLegend(result);
  1671. }
  1673. BOOL CMapXTheme::GetAutoRecompute()
  1674. {
  1675. BOOL result;
  1676. GetProperty(0x5, VT_BOOL, (void*)&result);
  1677. return result;
  1678. }
  1680. void CMapXTheme::SetAutoRecompute(BOOL propVal)
  1681. {
  1682. SetProperty(0x5, VT_BOOL, propVal);
  1683. }
  1685. CString CMapXTheme::GetName()
  1686. {
  1687. CString result;
  1688. GetProperty(0x6, VT_BSTR, (void*)&result);
  1689. return result;
  1690. }
  1692. void CMapXTheme::SetName(LPCTSTR propVal)
  1693. {
  1694. SetProperty(0x6, VT_BSTR, propVal);
  1695. }
  1697. CMapXThemeProperties CMapXTheme::GetThemeProperties()
  1698. {
  1699. LPDISPATCH result;
  1700. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  1701. return CMapXThemeProperties(result);
  1702. }
  1704. CMapXLayer CMapXTheme::GetLayer()
  1705. {
  1706. LPDISPATCH result;
  1707. GetProperty(0x9, VT_DISPATCH, (void*)&result);
  1708. return CMapXLayer(result);
  1709. }
  1711. CMapXFields CMapXTheme::GetFields()
  1712. {
  1713. LPDISPATCH result;
  1714. GetProperty(0xa, VT_DISPATCH, (void*)&result);
  1715. return CMapXFields(result);
  1716. }
  1718. double CMapXTheme::GetDataMin()
  1719. {
  1720. double result;
  1721. GetProperty(0xb, VT_R8, (void*)&result);
  1722. return result;
  1723. }
  1725. void CMapXTheme::SetDataMin(double propVal)
  1726. {
  1727. SetProperty(0xb, VT_R8, propVal);
  1728. }
  1730. double CMapXTheme::GetDataMax()
  1731. {
  1732. double result;
  1733. GetProperty(0xc, VT_R8, (void*)&result);
  1734. return result;
  1735. }
  1737. void CMapXTheme::SetDataMax(double propVal)
  1738. {
  1739. SetProperty(0xc, VT_R8, propVal);
  1740. }
  1742. BOOL CMapXTheme::GetComputeTheme()
  1743. {
  1744. BOOL result;
  1745. GetProperty(0xd, VT_BOOL, (void*)&result);
  1746. return result;
  1747. }
  1749. void CMapXTheme::SetComputeTheme(BOOL propVal)
  1750. {
  1751. SetProperty(0xd, VT_BOOL, propVal);
  1752. }
  1754. long CMapXTheme::GetThemedFeatureType()
  1755. {
  1756. long result;
  1757. GetProperty(0xe, VT_I4, (void*)&result);
  1758. return result;
  1759. }
  1761. /////////////////////////////////////////////////////////////////////////////
  1762. // CMapXTheme operations
  1764. BOOL CMapXTheme::ThemeDlg(const VARIANT& HelpFile, const VARIANT& HelpID)
  1765. {
  1766. BOOL bRetVal;
  1767. static BYTE parms[] =
  1768. VTS_VARIANT VTS_VARIANT;
  1769. InvokeHelper(0x8, DISPATCH_METHOD, VT_BOOL, (void*)&bRetVal, parms,
  1770. &HelpFile, &HelpID);
  1771. return bRetVal;
  1772. }
  1775. /////////////////////////////////////////////////////////////////////////////
  1776. // CMapXLegend properties
  1778. BOOL CMapXLegend::GetCompact()
  1779. {
  1780. BOOL result;
  1781. GetProperty(0x1, VT_BOOL, (void*)&result);
  1782. return result;
  1783. }
  1785. void CMapXLegend::SetCompact(BOOL propVal)
  1786. {
  1787. SetProperty(0x1, VT_BOOL, propVal);
  1788. }
  1790. BOOL CMapXLegend::GetVisible()
  1791. {
  1792. BOOL result;
  1793. GetProperty(0x2, VT_BOOL, (void*)&result);
  1794. return result;
  1795. }
  1797. void CMapXLegend::SetVisible(BOOL propVal)
  1798. {
  1799. SetProperty(0x2, VT_BOOL, propVal);
  1800. }
  1802. CMapXStyle CMapXLegend::GetTitleStyle()
  1803. {
  1804. LPDISPATCH result;
  1805. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  1806. return CMapXStyle(result);
  1807. }
  1809. void CMapXLegend::SetTitleStyle(LPDISPATCH propVal)
  1810. {
  1811. SetProperty(0x3, VT_DISPATCH, propVal);
  1812. }
  1814. CMapXStyle CMapXLegend::GetSubTitleStyle()
  1815. {
  1816. LPDISPATCH result;
  1817. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  1818. return CMapXStyle(result);
  1819. }
  1821. void CMapXLegend::SetSubTitleStyle(LPDISPATCH propVal)
  1822. {
  1823. SetProperty(0x4, VT_DISPATCH, propVal);
  1824. }
  1826. CMapXStyle CMapXLegend::GetCompactTitleStyle()
  1827. {
  1828. LPDISPATCH result;
  1829. GetProperty(0x5, VT_DISPATCH, (void*)&result);
  1830. return CMapXStyle(result);
  1831. }
  1833. void CMapXLegend::SetCompactTitleStyle(LPDISPATCH propVal)
  1834. {
  1835. SetProperty(0x5, VT_DISPATCH, propVal);
  1836. }
  1838. CMapXStyle CMapXLegend::GetBodyTextStyle()
  1839. {
  1840. LPDISPATCH result;
  1841. GetProperty(0x6, VT_DISPATCH, (void*)&result);
  1842. return CMapXStyle(result);
  1843. }
  1845. void CMapXLegend::SetBodyTextStyle(LPDISPATCH propVal)
  1846. {
  1847. SetProperty(0x6, VT_DISPATCH, propVal);
  1848. }
  1850. CMapXLegendTexts CMapXLegend::GetLegendTexts()
  1851. {
  1852. LPDISPATCH result;
  1853. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  1854. return CMapXLegendTexts(result);
  1855. }
  1857. BOOL CMapXLegend::GetCurrencyFormat()
  1858. {
  1859. BOOL result;
  1860. GetProperty(0x8, VT_BOOL, (void*)&result);
  1861. return result;
  1862. }
  1864. void CMapXLegend::SetCurrencyFormat(BOOL propVal)
  1865. {
  1866. SetProperty(0x8, VT_BOOL, propVal);
  1867. }
  1869. CString CMapXLegend::GetTitle()
  1870. {
  1871. CString result;
  1872. GetProperty(0x9, VT_BSTR, (void*)&result);
  1873. return result;
  1874. }
  1876. void CMapXLegend::SetTitle(LPCTSTR propVal)
  1877. {
  1878. SetProperty(0x9, VT_BSTR, propVal);
  1879. }
  1881. CString CMapXLegend::GetSubTitle()
  1882. {
  1883. CString result;
  1884. GetProperty(0xa, VT_BSTR, (void*)&result);
  1885. return result;
  1886. }
  1888. void CMapXLegend::SetSubTitle(LPCTSTR propVal)
  1889. {
  1890. SetProperty(0xa, VT_BSTR, propVal);
  1891. }
  1893. CString CMapXLegend::GetCompactTitle()
  1894. {
  1895. CString result;
  1896. GetProperty(0xb, VT_BSTR, (void*)&result);
  1897. return result;
  1898. }
  1900. void CMapXLegend::SetCompactTitle(LPCTSTR propVal)
  1901. {
  1902. SetProperty(0xb, VT_BSTR, propVal);
  1903. }
  1905. double CMapXLegend::GetLeft()
  1906. {
  1907. double result;
  1908. GetProperty(0xc, VT_R8, (void*)&result);
  1909. return result;
  1910. }
  1912. void CMapXLegend::SetLeft(double propVal)
  1913. {
  1914. SetProperty(0xc, VT_R8, propVal);
  1915. }
  1917. double CMapXLegend::GetTop()
  1918. {
  1919. double result;
  1920. GetProperty(0xd, VT_R8, (void*)&result);
  1921. return result;
  1922. }
  1924. void CMapXLegend::SetTop(double propVal)
  1925. {
  1926. SetProperty(0xd, VT_R8, propVal);
  1927. }
  1929. double CMapXLegend::GetWidth()
  1930. {
  1931. double result;
  1932. GetProperty(0xe, VT_R8, (void*)&result);
  1933. return result;
  1934. }
  1936. double CMapXLegend::GetHeight()
  1937. {
  1938. double result;
  1939. GetProperty(0xf, VT_R8, (void*)&result);
  1940. return result;
  1941. }
  1943. BOOL CMapXLegend::GetShowEmptyRanges()
  1944. {
  1945. BOOL result;
  1946. GetProperty(0x11, VT_BOOL, (void*)&result);
  1947. return result;
  1948. }
  1950. void CMapXLegend::SetShowEmptyRanges(BOOL propVal)
  1951. {
  1952. SetProperty(0x11, VT_BOOL, propVal);
  1953. }
  1955. BOOL CMapXLegend::GetShowCount()
  1956. {
  1957. BOOL result;
  1958. GetProperty(0x13, VT_BOOL, (void*)&result);
  1959. return result;
  1960. }
  1962. void CMapXLegend::SetShowCount(BOOL propVal)
  1963. {
  1964. SetProperty(0x13, VT_BOOL, propVal);
  1965. }
  1967. double CMapXLegend::GetPaperHeight()
  1968. {
  1969. double result;
  1970. GetProperty(0x15, VT_R8, (void*)&result);
  1971. return result;
  1972. }
  1974. double CMapXLegend::GetPaperWidth()
  1975. {
  1976. double result;
  1977. GetProperty(0x16, VT_R8, (void*)&result);
  1978. return result;
  1979. }
  1981. /////////////////////////////////////////////////////////////////////////////
  1982. // CMapXLegend operations
  1984. BOOL CMapXLegend::LegendDlg(const VARIANT& HelpFile, const VARIANT& HelpID)
  1985. {
  1986. BOOL bRetVal;
  1987. static BYTE parms[] =
  1988. VTS_VARIANT VTS_VARIANT;
  1989. InvokeHelper(0x10, DISPATCH_METHOD, VT_BOOL, (void*)&bRetVal, parms,
  1990. &HelpFile, &HelpID);
  1991. return(bRetVal);
  1992. }
  1994. void CMapXLegend::ExportLegend(LPCTSTR Destination, short Format)
  1995. {
  1996. static BYTE parms[] =
  1997. VTS_BSTR VTS_I2;
  1998. InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1999.  Destination, Format);
  2000. }
  2002. void CMapXLegend::PrintLegend(long hDC, long X, long Y, long W, long H)
  2003. {
  2004. static BYTE parms[] =
  2005. VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  2006. InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2007.  hDC, X, Y, W, H);
  2008. }
  2011. /////////////////////////////////////////////////////////////////////////////
  2012. // CMapXAnnotations properties
  2014. LPENUMVARIANT CMapXAnnotations::GetEnumerator()
  2015. {
  2016. LPENUMVARIANT pEnumVariant = 0;
  2017. LPUNKNOWN pUnknown = 0;
  2018. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  2019. if(pUnknown)
  2020. {
  2021. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  2022. pUnknown->Release();
  2023. }
  2024. return pEnumVariant;
  2025. }
  2027. BOOL CMapXAnnotations::GetEditable()
  2028. {
  2029. BOOL result;
  2030. GetProperty(0x1, VT_BOOL, (void*)&result);
  2031. return result;
  2032. }
  2034. void CMapXAnnotations::SetEditable(BOOL propVal)
  2035. {
  2036. SetProperty(0x1, VT_BOOL, propVal);
  2037. }
  2039. long CMapXAnnotations::GetCount()
  2040. {
  2041. long result;
  2042. GetProperty(0x2, VT_I4, (void*)&result);
  2043. return result;
  2044. }
  2046. /////////////////////////////////////////////////////////////////////////////
  2047. // CMapXAnnotations operations
  2049. CMapXAnnotation CMapXAnnotations::AddSymbol(double X, double Y)
  2050. {
  2051. LPDISPATCH result;
  2052. static BYTE parms[] =
  2053. VTS_R8 VTS_R8;
  2054. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2055. X, Y);
  2056. return CMapXAnnotation(result);
  2057. }
  2059. CMapXAnnotation CMapXAnnotations::Item(const VARIANT& Index)
  2060. {
  2061. LPDISPATCH result;
  2062. static BYTE parms[] =
  2063. VTS_VARIANT;
  2064. InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2065. &Index);
  2066. return CMapXAnnotation(result);
  2067. }
  2069. void CMapXAnnotations::Remove(const VARIANT& Index)
  2070. {
  2071. static BYTE parms[] =
  2072. VTS_VARIANT;
  2073. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2074.  &Index);
  2075. }
  2077. CMapXAnnotation CMapXAnnotations::AddText(LPCTSTR Text, double X, double Y, const VARIANT& Position)
  2078. {
  2079. LPDISPATCH result;
  2080. static BYTE parms[] =
  2081. VTS_BSTR VTS_R8 VTS_R8 VTS_VARIANT;
  2082. InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2083. Text, X, Y, &Position);
  2084. return CMapXAnnotation(result);
  2085. }
  2087. void CMapXAnnotations::RemoveAll()
  2088. {
  2089. InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2090. }
  2092. CMapXAnnotation CMapXAnnotations::ActiveAnnotation()
  2093. {
  2094. LPDISPATCH result;
  2095. GetProperty(0x8, VT_DISPATCH, (void*)&result);
  2096. return CMapXAnnotation(result);
  2097. }
  2100. /////////////////////////////////////////////////////////////////////////////
  2101. // CMapXThemeProperties properties
  2103. short CMapXThemeProperties::GetDistMethod()
  2104. {
  2105. short result;
  2106. GetProperty(0x1, VT_I2, (void*)&result);
  2107. return result;
  2108. }
  2110. void CMapXThemeProperties::SetDistMethod(short propVal)
  2111. {
  2112. SetProperty(0x1, VT_I2, propVal);
  2113. }
  2115. short CMapXThemeProperties::GetNumRanges()
  2116. {
  2117. short result;
  2118. GetProperty(0x2, VT_I2, (void*)&result);
  2119. return result;
  2120. }
  2122. void CMapXThemeProperties::SetNumRanges(short propVal)
  2123. {
  2124. SetProperty(0x2, VT_I2, propVal);
  2125. }
  2127. CMapXRangeCategories CMapXThemeProperties::GetRangeCategories()
  2128. {
  2129. LPDISPATCH result;
  2130. GetProperty(0x3, VT_DISPATCH, (void*)&result);
  2131. return CMapXRangeCategories(result);
  2132. }
  2134. short CMapXThemeProperties::GetDotSize()
  2135. {
  2136. short result;
  2137. GetProperty(0x5, VT_I2, (void*)&result);
  2138. return result;
  2139. }
  2141. void CMapXThemeProperties::SetDotSize(short propVal)
  2142. {
  2143. SetProperty(0x5, VT_I2, propVal);
  2144. }
  2146. BOOL CMapXThemeProperties::GetGraduated()
  2147. {
  2148. BOOL result;
  2149. GetProperty(0x6, VT_BOOL, (void*)&result);
  2150. return result;
  2151. }
  2153. void CMapXThemeProperties::SetGraduated(BOOL propVal)
  2154. {
  2155. SetProperty(0x6, VT_BOOL, propVal);
  2156. }
  2158. CMapXMultivarCategories CMapXThemeProperties::GetMultivarCategories()
  2159. {
  2160. LPDISPATCH result;
  2161. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  2162. return CMapXMultivarCategories(result);
  2163. }
  2165. BOOL CMapXThemeProperties::GetIndependent()
  2166. {
  2167. BOOL result;
  2168. GetProperty(0x8, VT_BOOL, (void*)&result);
  2169. return result;
  2170. }
  2172. void CMapXThemeProperties::SetIndependent(BOOL propVal)
  2173. {
  2174. SetProperty(0x8, VT_BOOL, propVal);
  2175. }
  2177. CMapXIndividualValueCategories CMapXThemeProperties::GetIndividualValueCategories()
  2178. {
  2179. LPDISPATCH result;
  2180. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  2181. return CMapXIndividualValueCategories(result);
  2182. }
  2184. double CMapXThemeProperties::GetValuePerDot()
  2185. {
  2186. double result;
  2187. GetProperty(0x9, VT_R8, (void*)&result);
  2188. return result;
  2189. }
  2191. void CMapXThemeProperties::SetValuePerDot(double propVal)
  2192. {
  2193. SetProperty(0x9, VT_R8, propVal);
  2194. }
  2196. double CMapXThemeProperties::GetDataValue()
  2197. {
  2198. double result;
  2199. GetProperty(0xa, VT_R8, (void*)&result);
  2200. return result;
  2201. }
  2203. void CMapXThemeProperties::SetDataValue(double propVal)
  2204. {
  2205. SetProperty(0xa, VT_R8, propVal);
  2206. }
  2208. double CMapXThemeProperties::GetSize()
  2209. {
  2210. double result;
  2211. GetProperty(0xb, VT_R8, (void*)&result);
  2212. return result;
  2213. }
  2215. void CMapXThemeProperties::SetSize(double propVal)
  2216. {
  2217. SetProperty(0xb, VT_R8, propVal);
  2218. }
  2220. double CMapXThemeProperties::GetWidth()
  2221. {
  2222. double result;
  2223. GetProperty(0xc, VT_R8, (void*)&result);
  2224. return result;
  2225. }
  2227. void CMapXThemeProperties::SetWidth(double propVal)
  2228. {
  2229. SetProperty(0xc, VT_R8, propVal);
  2230. }
  2232. CMapXStyle CMapXThemeProperties::GetSymbolStyle()
  2233. {
  2234. LPDISPATCH result;
  2235. GetProperty(0xd, VT_DISPATCH, (void*)&result);
  2236. return CMapXStyle(result);
  2237. }
  2239. void CMapXThemeProperties::SetSymbolStyle(LPDISPATCH propVal)
  2240. {
  2241. SetProperty(0xd, VT_DISPATCH, propVal);
  2242. }
  2244. short CMapXThemeProperties::GetSpreadBy()
  2245. {
  2246. short result;
  2247. GetProperty(0xe, VT_I2, (void*)&result);
  2248. return result;
  2249. }
  2251. void CMapXThemeProperties::SetSpreadBy(short propVal)
  2252. {
  2253. SetProperty(0xe, VT_I2, propVal);
  2254. }
  2256. BOOL CMapXThemeProperties::GetAllowEmptyRanges()
  2257. {
  2258. BOOL result;
  2259. GetProperty(0xf, VT_BOOL, (void*)&result);
  2260. return result;
  2261. }
  2263. void CMapXThemeProperties::SetAllowEmptyRanges(BOOL propVal)
  2264. {
  2265. SetProperty(0xf, VT_BOOL, propVal);
  2266. }
  2268. unsigned long CMapXThemeProperties::GetDotColor()
  2269. {
  2270. unsigned long result;
  2271. GetProperty(0x10, VT_I4, (void*)&result);
  2272. return result;
  2273. }
  2275. void CMapXThemeProperties::SetDotColor(unsigned long propVal)
  2276. {
  2277. SetProperty(0x10, VT_I4, propVal);
  2278. }
  2280. BOOL CMapXThemeProperties::GetPieClockwise()
  2281. {
  2282. BOOL result;
  2283. GetProperty(0x11, VT_BOOL, (void*)&result);
  2284. return result;
  2285. }
  2287. void CMapXThemeProperties::SetPieClockwise(BOOL propVal)
  2288. {
  2289. SetProperty(0x11, VT_BOOL, propVal);
  2290. }
  2292. BOOL CMapXThemeProperties::GetPieHalfPies()
  2293. {
  2294. BOOL result;
  2295. GetProperty(0x12, VT_BOOL, (void*)&result);
  2296. return result;
  2297. }
  2299. void CMapXThemeProperties::SetPieHalfPies(BOOL propVal)
  2300. {
  2301. SetProperty(0x12, VT_BOOL, propVal);
  2302. }
  2304. short CMapXThemeProperties::GetPieStartAngle()
  2305. {
  2306. short result;
  2307. GetProperty(0x13, VT_I2, (void*)&result);
  2308. return result;
  2309. }
  2311. void CMapXThemeProperties::SetPieStartAngle(short propVal)
  2312. {
  2313. SetProperty(0x13, VT_I2, propVal);
  2314. }
  2316. BOOL CMapXThemeProperties::GetBarStacked()
  2317. {
  2318. BOOL result;
  2319. GetProperty(0x14, VT_BOOL, (void*)&result);
  2320. return result;
  2321. }
  2323. void CMapXThemeProperties::SetBarStacked(BOOL propVal)
  2324. {
  2325. SetProperty(0x14, VT_BOOL, propVal);
  2326. }
  2328. CMapXStyle CMapXThemeProperties::GetNegativeSymbolStyle()
  2329. {
  2330. LPDISPATCH result;
  2331. GetProperty(0x15, VT_DISPATCH, (void*)&result);
  2332. return CMapXStyle(result);
  2333. }
  2335. void CMapXThemeProperties::SetNegativeSymbolStyle(LPDISPATCH propVal)
  2336. {
  2337. SetProperty(0x15, VT_DISPATCH, propVal);
  2338. }
  2340. BOOL CMapXThemeProperties::GetShowNegativeValues()
  2341. {
  2342. BOOL result;
  2343. GetProperty(0x16, VT_BOOL, (void*)&result);
  2344. return result;
  2345. }
  2347. void CMapXThemeProperties::SetShowNegativeValues(BOOL propVal)
  2348. {
  2349. SetProperty(0x16, VT_BOOL, propVal);
  2350. }
  2352. short CMapXThemeProperties::GetGraduateSizeBy()
  2353. {
  2354. short result;
  2355. GetProperty(0x17, VT_I2, (void*)&result);
  2356. return result;
  2357. }
  2359. void CMapXThemeProperties::SetGraduateSizeBy(short propVal)
  2360. {
  2361. SetProperty(0x17, VT_I2, propVal);
  2362. }
  2364. CMapXStyle CMapXThemeProperties::GetBorderStyle()
  2365. {
  2366. LPDISPATCH result;
  2367. GetProperty(0x18, VT_DISPATCH, (void*)&result);
  2368. return CMapXStyle(result);
  2369. }
  2371. void CMapXThemeProperties::SetBorderStyle(LPDISPATCH propVal)
  2372. {
  2373. SetProperty(0x18, VT_DISPATCH, propVal);
  2374. }
  2376. double CMapXThemeProperties::GetBarWidth()
  2377. {
  2378. double result;
  2379. GetProperty(0x19, VT_R8, (void*)&result);
  2380. return result;
  2381. }
  2383. void CMapXThemeProperties::SetBarWidth(double propVal)
  2384. {
  2385. SetProperty(0x19, VT_R8, propVal);
  2386. }
  2388. BOOL CMapXThemeProperties::GetBarIndependentScale()
  2389. {
  2390. BOOL result;
  2391. GetProperty(0x1a, VT_BOOL, (void*)&result);
  2392. return result;
  2393. }
  2395. void CMapXThemeProperties::SetBarIndependentScale(BOOL propVal)
  2396. {
  2397. SetProperty(0x1a, VT_BOOL, propVal);
  2398. }
  2400. CMapXStyle CMapXThemeProperties::GetPositiveSymbolStyle()
  2401. {
  2402. LPDISPATCH result;
  2403. GetProperty(0x1b, VT_DISPATCH, (void*)&result);
  2404. return CMapXStyle(result);
  2405. }
  2407. void CMapXThemeProperties::SetPositiveSymbolStyle(LPDISPATCH propVal)
  2408. {
  2409. SetProperty(0x1b, VT_DISPATCH, propVal);
  2410. }
  2412. CMapXStyle CMapXThemeProperties::GetBarFrameStyle()
  2413. {
  2414. LPDISPATCH result;
  2415. GetProperty(0x1c, VT_DISPATCH, (void*)&result);
  2416. return CMapXStyle(result);
  2417. }
  2419. void CMapXThemeProperties::SetBarFrameStyle(LPDISPATCH propVal)
  2420. {
  2421. SetProperty(0x1c, VT_DISPATCH, propVal);
  2422. }
  2424. BOOL CMapXThemeProperties::GetPieGraduated()
  2425. {
  2426. BOOL result;
  2427. GetProperty(0x1d, VT_BOOL, (void*)&result);
  2428. return result;
  2429. }
  2431. void CMapXThemeProperties::SetPieGraduated(BOOL propVal)
  2432. {
  2433. SetProperty(0x1d, VT_BOOL, propVal);
  2434. }
  2436. BOOL CMapXThemeProperties::GetBarGraduatedStack()
  2437. {
  2438. BOOL result;
  2439. GetProperty(0x1e, VT_BOOL, (void*)&result);
  2440. return result;
  2441. }
  2443. void CMapXThemeProperties::SetBarGraduatedStack(BOOL propVal)
  2444. {
  2445. SetProperty(0x1e, VT_BOOL, propVal);
  2446. }
  2448. short CMapXThemeProperties::GetApplyAttribute()
  2449. {
  2450. short result;
  2451. GetProperty(0x1f, VT_I2, (void*)&result);
  2452. return result;
  2453. }
  2455. void CMapXThemeProperties::SetApplyAttribute(short propVal)
  2456. {
  2457. SetProperty(0x1f, VT_I2, propVal);
  2458. }
  2460. BOOL CMapXThemeProperties::GetRoundRanges()
  2461. {
  2462. BOOL result;
  2463. GetProperty(0x20, VT_BOOL, (void*)&result);
  2464. return result;
  2465. }
  2467. void CMapXThemeProperties::SetRoundRanges(BOOL propVal)
  2468. {
  2469. SetProperty(0x20, VT_BOOL, propVal);
  2470. }
  2472. double CMapXThemeProperties::GetRoundBy()
  2473. {
  2474. double result;
  2475. GetProperty(0x21, VT_R8, (void*)&result);
  2476. return result;
  2477. }
  2479. void CMapXThemeProperties::SetRoundBy(double propVal)
  2480. {
  2481. SetProperty(0x21, VT_R8, propVal);
  2482. }
  2484. short CMapXThemeProperties::GetColorMethod()
  2485. {
  2486. short result;
  2487. GetProperty(0x22, VT_I2, (void*)&result);
  2488. return result;
  2489. }
  2491. void CMapXThemeProperties::SetColorMethod(short propVal)
  2492. {
  2493. SetProperty(0x22, VT_I2, propVal);
  2494. }
  2496. BOOL CMapXThemeProperties::GetInflectRanges()
  2497. {
  2498. BOOL result;
  2499. GetProperty(0x23, VT_BOOL, (void*)&result);
  2500. return result;
  2501. }
  2503. void CMapXThemeProperties::SetInflectRanges(BOOL propVal)
  2504. {
  2505. SetProperty(0x23, VT_BOOL, propVal);
  2506. }
  2508. short CMapXThemeProperties::GetInflectionRange()
  2509. {
  2510. short result;
  2511. GetProperty(0x24, VT_I2, (void*)&result);
  2512. return result;
  2513. }
  2515. void CMapXThemeProperties::SetInflectionRange(short propVal)
  2516. {
  2517. SetProperty(0x24, VT_I2, propVal);
  2518. }
  2520. unsigned long CMapXThemeProperties::GetInflectionColor()
  2521. {
  2522. unsigned long result;
  2523. GetProperty(0x25, VT_I4, (void*)&result);
  2524. return result;
  2525. }
  2527. void CMapXThemeProperties::SetInflectionColor(unsigned long propVal)
  2528. {
  2529. SetProperty(0x25, VT_I4, propVal);
  2530. }
  2532. BOOL CMapXThemeProperties::GetBarFramed()
  2533. {
  2534. BOOL result;
  2535. GetProperty(0x26, VT_BOOL, (void*)&result);
  2536. return result;
  2537. }
  2539. void CMapXThemeProperties::SetBarFramed(BOOL propVal)
  2540. {
  2541. SetProperty(0x26, VT_BOOL, propVal);
  2542. }
  2544. /////////////////////////////////////////////////////////////////////////////
  2545. // CMapXThemeProperties operations
  2548. /////////////////////////////////////////////////////////////////////////////
  2549. // CMapXSelection properties
  2551. LPENUMVARIANT CMapXSelection::GetEnumerator()
  2552. {
  2553. LPENUMVARIANT pEnumVariant = 0;
  2554. LPUNKNOWN pUnknown = 0;
  2555. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  2556. if(pUnknown)
  2557. {
  2558. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  2559. pUnknown->Release();
  2560. }
  2561. return pEnumVariant;
  2562. }
  2564. long CMapXSelection::GetCount()
  2565. {
  2566. long result;
  2567. GetProperty(0x10001, VT_I4, (void*)&result);
  2568. return result;
  2569. }
  2571. CMapXRectangle CMapXSelection::GetBounds()
  2572. {
  2573. LPDISPATCH result;
  2574. GetProperty(0x10008, VT_DISPATCH, (void*)&result);
  2575. return CMapXRectangle(result);
  2576. }
  2578. /////////////////////////////////////////////////////////////////////////////
  2579. // CMapXSelection operations
  2581. CMapXFeature CMapXSelection::Item(const VARIANT& Index)
  2582. {
  2583. LPDISPATCH result;
  2584. static BYTE parms[] =
  2585. VTS_VARIANT;
  2586. InvokeHelper(0x10002, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2587. &Index);
  2588. return CMapXFeature(result);
  2589. }
  2591. CMapXFeatures CMapXSelection::Clone()
  2592. {
  2593. LPDISPATCH result;
  2594. InvokeHelper(0x10003, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  2595. return CMapXFeatures(result);
  2596. }
  2598. void CMapXSelection::Add(LPDISPATCH Source)
  2599. {
  2600. static BYTE parms[] =
  2601. VTS_DISPATCH;
  2602. InvokeHelper(0x10004, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2603.  Source);
  2604. }
  2606. void CMapXSelection::Common(LPDISPATCH Source)
  2607. {
  2608. static BYTE parms[] =
  2609. VTS_DISPATCH;
  2610. InvokeHelper(0x10005, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2611.  Source);
  2612. }
  2614. void CMapXSelection::Remove(const VARIANT& Source)
  2615. {
  2616. static BYTE parms[] =
  2617. VTS_VARIANT;
  2618. InvokeHelper(0x10006, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2619.  &Source);
  2620. }
  2622. void CMapXSelection::Replace(LPDISPATCH Source)
  2623. {
  2624. static BYTE parms[] =
  2625. VTS_DISPATCH;
  2626. InvokeHelper(0x10007, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2627.  Source);
  2628. }
  2630. void CMapXSelection::AddByID(const VARIANT& FeatureID)
  2631. {
  2632. static BYTE parms[] =
  2633. VTS_VARIANT;
  2634. InvokeHelper(0x10009, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2635.  &FeatureID);
  2636. }
  2638. void CMapXSelection::RemoveByID(const VARIANT& FeatureID)
  2639. {
  2640. static BYTE parms[] =
  2641. VTS_VARIANT;
  2642. InvokeHelper(0x1000a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2643.  &FeatureID);
  2644. }
  2646. void CMapXSelection::SelectByRegion(LPDISPATCH Layer, const VARIANT& FeatureID, short Flag)
  2647. {
  2648. static BYTE parms[] =
  2649. VTS_DISPATCH VTS_VARIANT VTS_I2;
  2650. InvokeHelper(0x1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2651.  Layer, &FeatureID, Flag);
  2652. }
  2654. void CMapXSelection::ClearSelection()
  2655. {
  2656. InvokeHelper(0x2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2657. }
  2659. void CMapXSelection::SelectByPoint(double X, double Y, short SelectFlag, short SearchResultFlags)
  2660. {
  2661. static BYTE parms[] =
  2662. VTS_R8 VTS_R8 VTS_I2 VTS_I2;
  2663. InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2664.  X, Y, SelectFlag, SearchResultFlags);
  2665. }
  2667. void CMapXSelection::SelectByRadius(double X, double Y, double radius, short Flag)
  2668. {
  2669. static BYTE parms[] =
  2670. VTS_R8 VTS_R8 VTS_R8 VTS_I2;
  2671. InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2672.  X, Y, radius, Flag);
  2673. }
  2675. void CMapXSelection::SelectByRectangle(double X1, double Y1, double X2, double Y2, short Flag)
  2676. {
  2677. static BYTE parms[] =
  2678. VTS_R8 VTS_R8 VTS_R8 VTS_R8 VTS_I2;
  2679. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2680.  X1, Y1, X2, Y2, Flag);
  2681. }
  2683. BOOL CMapXSelection::SelectAll(short Flag)
  2684. {
  2685. BOOL result;
  2686. static BYTE parms[] =
  2687. VTS_I2;
  2688. InvokeHelper(0x6, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  2689. Flag);
  2690. return result;
  2691. }
  2693. void CMapXSelection::SelectByID(const VARIANT& FeatureID, short Flag)
  2694. {
  2695. static BYTE parms[] =
  2696. VTS_VARIANT VTS_I2;
  2697. InvokeHelper(0x7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2698.  &FeatureID, Flag);
  2699. }
  2702. /////////////////////////////////////////////////////////////////////////////
  2703. // CMapXFeature properties
  2705. long CMapXFeature::GetFeatureID()
  2706. {
  2707. long result;
  2708. GetProperty(0x1, VT_I4, (void*)&result);
  2709. return result;
  2710. }
  2712. short CMapXFeature::GetType()
  2713. {
  2714. short result;
  2715. GetProperty(0x2, VT_I2, (void*)&result);
  2716. return result;
  2717. }
  2719. void CMapXFeature::SetType(short propVal)
  2720. {
  2721. SetProperty(0x2, VT_I2, propVal);
  2722. }
  2724. double CMapXFeature::GetLength()
  2725. {
  2726. double result;
  2727. GetProperty(0x3, VT_R8, (void*)&result);
  2728. return result;
  2729. }
  2731. double CMapXFeature::GetCenterX()
  2732. {
  2733. double result;
  2734. GetProperty(0x4, VT_R8, (void*)&result);
  2735. return result;
  2736. }
  2738. double CMapXFeature::GetCenterY()
  2739. {
  2740. double result;
  2741. GetProperty(0x5, VT_R8, (void*)&result);
  2742. return result;
  2743. }
  2745. CMapXStyle CMapXFeature::GetStyle()
  2746. {
  2747. LPDISPATCH result;
  2748. GetProperty(0x6, VT_DISPATCH, (void*)&result);
  2749. return CMapXStyle(result);
  2750. }
  2752. void CMapXFeature::SetStyle(LPDISPATCH propVal)
  2753. {
  2754. SetProperty(0x6, VT_DISPATCH, propVal);
  2755. }
  2757. CMapXRectangle CMapXFeature::GetBounds()
  2758. {
  2759. LPDISPATCH result;
  2760. GetProperty(0x7, VT_DISPATCH, (void*)&result);
  2761. return CMapXRectangle(result);
  2762. }
  2764. CString CMapXFeature::GetCaption()
  2765. {
  2766. CString result;
  2767. GetProperty(0x8, VT_BSTR, (void*)&result);
  2768. return result;
  2769. }
  2771. void CMapXFeature::SetCaption(LPCTSTR propVal)
  2772. {
  2773. SetProperty(0x8, VT_BSTR, propVal);
  2774. }
  2776. CMapXParts CMapXFeature::GetParts()
  2777. {
  2778. LPDISPATCH result;
  2779. GetProperty(0x9, VT_DISPATCH, (void*)&result);
  2780. return CMapXParts(result);
  2781. }
  2783. double CMapXFeature::GetArea()
  2784. {
  2785. double result;
  2786. GetProperty(0xa, VT_R8, (void*)&result);
  2787. return result;
  2788. }
  2790. CMapXLayer CMapXFeature::GetLayer()
  2791. {
  2792. LPDISPATCH result;
  2793. GetProperty(0xb, VT_DISPATCH, (void*)&result);
  2794. return CMapXLayer(result);
  2795. }
  2797. CMapXPoint CMapXFeature::GetPoint()
  2798. {
  2799. LPDISPATCH result;
  2800. GetProperty(0xc, VT_DISPATCH, (void*)&result);
  2801. return CMapXPoint(result);
  2802. }
  2804. void CMapXFeature::SetPoint(LPDISPATCH propVal)
  2805. {
  2806. SetProperty(0xc, VT_DISPATCH, propVal);
  2807. }
  2809. CMapXPoint CMapXFeature::GetLabelPoint()
  2810. {
  2811. LPDISPATCH result;
  2812. GetProperty(0xd, VT_DISPATCH, (void*)&result);
  2813. return CMapXPoint(result);
  2814. }
  2816. double CMapXFeature::GetPerimeter()
  2817. {
  2818. double result;
  2819. GetProperty(0xe, VT_R8, (void*)&result);
  2820. return result;
  2821. }
  2823. BOOL CMapXFeature::GetSmooth()
  2824. {
  2825. BOOL result;
  2826. GetProperty(0xf, VT_BOOL, (void*)&result);
  2827. return result;
  2828. }
  2830. void CMapXFeature::SetSmooth(BOOL propVal)
  2831. {
  2832. SetProperty(0xf, VT_BOOL, propVal);
  2833. }
  2835. CString CMapXFeature::GetName()
  2836. {
  2837. CString result;
  2838. GetProperty(0x10, VT_BSTR, (void*)&result);
  2839. return result;
  2840. }
  2842. CString CMapXFeature::GetKeyValue()
  2843. {
  2844. CString result;
  2845. GetProperty(0x11, VT_BSTR, (void*)&result);
  2846. return result;
  2847. }
  2849. void CMapXFeature::SetKeyValue(LPCTSTR propVal)
  2850. {
  2851. SetProperty(0x11, VT_BSTR, propVal);
  2852. }
  2854. CString CMapXFeature::GetFeatureKey()
  2855. {
  2856. CString result;
  2857. GetProperty(0x17, VT_BSTR, (void*)&result);
  2858. return result;
  2859. }
  2861. CMapXFeature CMapXFeature::GetRegion()
  2862. {
  2863. LPDISPATCH result;
  2864. GetProperty(0x18, VT_DISPATCH, (void*)&result);
  2865. return CMapXFeature(result);
  2866. }
  2868. void CMapXFeature::SetRegion(LPDISPATCH propVal)
  2869. {
  2870. SetProperty(0x18, VT_DISPATCH, propVal);
  2871. }
  2873. CMapXFeature CMapXFeature::GetPolyline()
  2874. {
  2875. LPDISPATCH result;
  2876. GetProperty(0x19, VT_DISPATCH, (void*)&result);
  2877. return CMapXFeature(result);
  2878. }
  2880. void CMapXFeature::SetPolyline(LPDISPATCH propVal)
  2881. {
  2882. SetProperty(0x19, VT_DISPATCH, propVal);
  2883. }
  2885. CMapXFeature CMapXFeature::GetMultipoint()
  2886. {
  2887. LPDISPATCH result;
  2888. GetProperty(0x1A, VT_DISPATCH, (void*)&result);
  2889. return CMapXFeature(result);
  2890. }
  2892. void CMapXFeature::SetMultipoint(LPDISPATCH propVal)
  2893. {
  2894. SetProperty(0x1A, VT_DISPATCH, propVal);
  2895. }
  2897. BOOL CMapXFeature::GetHasRegion()
  2898. {
  2899. BOOL result;
  2900. GetProperty(0x1B, VT_BOOL, (void*)&result);
  2901. return result;
  2902. }
  2904. BOOL CMapXFeature::GetHasPolyline()
  2905. {
  2906. BOOL result;
  2907. GetProperty(0x1C, VT_BOOL, (void*)&result);
  2908. return result;
  2909. }
  2911. BOOL CMapXFeature::GetHasMultipoint()
  2912. {
  2913. BOOL result;
  2914. GetProperty(0x1D, VT_BOOL, (void*)&result);
  2915. return result;
  2916. }
  2917. /////////////////////////////////////////////////////////////////////////////
  2918. // CMapXFeature operations
  2920. void CMapXFeature::Update(const VARIANT& UpdateFeature, const VARIANT& RowValues)
  2921. {
  2922. static BYTE parms[] =
  2923. VTS_VARIANT VTS_VARIANT;
  2924. InvokeHelper(0x12, DISPATCH_METHOD, VT_EMPTY, NULL, parms, &UpdateFeature, &RowValues);
  2925. }
  2927. void CMapXFeature::Offset(double deltaX, double deltaY)
  2928. {
  2929. static BYTE parms[] =
  2930. VTS_R8 VTS_R8;
  2931. InvokeHelper(0x13, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2932.  deltaX, deltaY);
  2933. }
  2935. void CMapXFeature::Attach(LPDISPATCH Map)
  2936. {
  2937. static BYTE parms[] =
  2938. VTS_DISPATCH;
  2939. InvokeHelper(0x14, DISPATCH_METHOD, VT_EMPTY, NULL, parms, Map);
  2940. }
  2942. CMapXFeature CMapXFeature::Clone()
  2943. {
  2944. LPDISPATCH result;
  2945. InvokeHelper(0x15, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  2946. return CMapXFeature(result);
  2947. }
  2949. VARIANT CMapXFeature::Nodes(const VARIANT& CSys)
  2950. {
  2951. VARIANT result;
  2952. static BYTE parms[] = VTS_VARIANT;
  2953. InvokeHelper(0x16, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms, &CSys);
  2954. return result;
  2955. }
  2957. VARIANT CMapXFeature::GetNodes(const VARIANT& CSys)
  2958. {
  2959. VARIANT result;
  2960. static BYTE parms[] =
  2961. VTS_VARIANT;
  2962. InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
  2963. &CSys);
  2964. return result;
  2965. }
  2967. void CMapXFeature::SetNodes(const VARIANT& CSys, const VARIANT& newValue)
  2968. {
  2969. static BYTE parms[] =
  2970. VTS_VARIANT VTS_VARIANT;
  2971. InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2972.  &CSys, &newValue);
  2973. }
  2975. /////////////////////////////////////////////////////////////////////////////
  2976. // CMapXFeatureFactory properties
  2978. /////////////////////////////////////////////////////////////////////////////
  2979. // CMapXFeatureFactory operations
  2981. CMapXFeature CMapXFeatureFactory::BufferFeatures(LPDISPATCH Source, double Distance, const VARIANT& Units, const VARIANT& Resolution)
  2982. {
  2983. LPDISPATCH result;
  2984. static BYTE parms[] =
  2985. VTS_DISPATCH VTS_R8 VTS_VARIANT VTS_VARIANT;
  2986. InvokeHelper(0x1, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2987. Source, Distance, &Units, &Resolution);
  2988. return CMapXFeature(result);
  2989. }
  2991. CMapXFeature CMapXFeatureFactory::CombineFeatures(LPDISPATCH Source1, const VARIANT& Source2)
  2992. {
  2993. LPDISPATCH result;
  2994. static BYTE parms[] =
  2995. VTS_DISPATCH VTS_VARIANT;
  2996. InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2997. Source1, &Source2);
  2998. return CMapXFeature(result);
  2999. }
  3001. CMapXFeature CMapXFeatureFactory::IntersectFeatures(LPDISPATCH Source1, const VARIANT& Source2)
  3002. {
  3003. LPDISPATCH result;
  3004. static BYTE parms[] =
  3005. VTS_DISPATCH VTS_VARIANT;
  3006. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3007. Source1, &Source2);
  3008. return CMapXFeature(result);
  3009. }
  3011. CMapXFeature CMapXFeatureFactory::EraseFeature(LPDISPATCH Feature, LPDISPATCH EraserFeature)
  3012. {
  3013. LPDISPATCH result;
  3014. static BYTE parms[] =
  3015. VTS_DISPATCH VTS_DISPATCH;
  3016. InvokeHelper(0x4, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3017. Feature, EraserFeature);
  3018. return CMapXFeature(result);
  3019. }
  3021. CMapXFeature CMapXFeatureFactory::CreateSymbol(const VARIANT& Point, const VARIANT& Style)
  3022. {
  3023. LPDISPATCH result;
  3024. static BYTE parms[] =
  3025. VTS_VARIANT VTS_VARIANT;
  3026. InvokeHelper(0x5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3027. &Point, &Style);
  3028. return CMapXFeature(result);
  3029. }
  3031. CMapXFeature CMapXFeatureFactory::CreateRegion(const VARIANT& Points, const VARIANT& Style)
  3032. {
  3033. LPDISPATCH result;
  3034. static BYTE parms[] =
  3035. VTS_VARIANT VTS_VARIANT;
  3036. InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3037. &Points, &Style);
  3038. return CMapXFeature(result);
  3039. }
  3041. CMapXFeature CMapXFeatureFactory::CreateLine(const VARIANT& Points, const VARIANT& Style)
  3042. {
  3043. LPDISPATCH result;
  3044. static BYTE parms[] =
  3045. VTS_VARIANT VTS_VARIANT;
  3046. InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3047. &Points, &Style);
  3048. return CMapXFeature(result);
  3049. }
  3051. CMapXFeature CMapXFeatureFactory::CreateText(const VARIANT& Point, const VARIANT& Caption, const VARIANT& Position, const VARIANT& Style)
  3052. {
  3053. LPDISPATCH result;
  3054. static BYTE parms[] =
  3055. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3056. InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3057. &Point, &Caption, &Position, &Style);
  3058. return CMapXFeature(result);
  3059. }
  3061. CMapXFeature CMapXFeatureFactory::CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, const VARIANT& Angle, const VARIANT& Distance, const VARIANT& Resolution, const VARIANT& Style)
  3062. {
  3063. LPDISPATCH result;
  3064. static BYTE parms[] =
  3065. VTS_DISPATCH VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3066. InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3067. Point1, Point2, &Angle, &Distance, &Resolution, &Style);
  3068. return CMapXFeature(result);
  3069. }
  3071. CMapXFeature CMapXFeatureFactory::CreateEllipticalRegion(LPDISPATCH Rectangle, const VARIANT& Angle, const VARIANT& Resolution, const VARIANT& Style)
  3072. {
  3073. LPDISPATCH result;
  3074. static BYTE parms[] =
  3075. VTS_DISPATCH VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3076. InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3077. Rectangle, &Angle, &Resolution, &Style);
  3078. return CMapXFeature(result);
  3079. }
  3081. CMapXFeature CMapXFeatureFactory::CreateCircularRegion(short Type, LPDISPATCH Point, double Distance, const VARIANT& Units, const VARIANT& Resolution, const VARIANT& Style)
  3082. {
  3083. LPDISPATCH result;
  3084. static BYTE parms[] =
  3085. VTS_I2 VTS_DISPATCH VTS_R8 VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3086. InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3087. Type, Point, Distance, &Units, &Resolution, &Style);
  3088. return CMapXFeature(result);
  3089. }
  3091. BOOL CMapXFeatureFactory::IntersectionTest(LPDISPATCH Feature1, LPDISPATCH Feature2, const VARIANT& Flag)
  3092. {
  3093. BOOL result;
  3094. static BYTE parms[] =
  3095. VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
  3096. InvokeHelper(0xc, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  3097. Feature1, Feature2, &Flag);
  3098. return result;
  3099. }
  3101. CMapXPoints CMapXFeatureFactory::IntersectionPoints(LPDISPATCH Feature1, LPDISPATCH Feature2, const VARIANT& Flag)
  3102. {
  3103. LPDISPATCH result;
  3104. static BYTE parms[] =
  3105. VTS_DISPATCH VTS_DISPATCH VTS_VARIANT;
  3106. InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3107. Feature1, Feature2, &Flag);
  3108. return CMapXPoints(result);
  3109. }
  3111. CMapXFeature CMapXFeatureFactory::CreateCollectionFeature(const VARIANT& Source1, const VARIANT& Source2, const VARIANT& Source3)
  3112. {
  3113. LPDISPATCH result;
  3114. static BYTE parms[] =
  3115. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3116. InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3117. &Source1, &Source2, &Source3);
  3118. return CMapXFeature(result);
  3119. }
  3121. CMapXFeature CMapXFeatureFactory::CreateMultipoint(const VARIANT& Points, const VARIANT& Style)
  3122. {
  3123. LPDISPATCH result;
  3124. static BYTE parms[] =
  3125. VTS_VARIANT VTS_VARIANT;
  3126. InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3127. &Points, &Style);
  3128. return CMapXFeature(result);
  3129. }
  3131. /////////////////////////////////////////////////////////////////////////////
  3132. // CMapXRangeCategory properties
  3134. double CMapXRangeCategory::GetMin()
  3135. {
  3136. double result;
  3137. GetProperty(0x1, VT_R8, (void*)&result);
  3138. return result;
  3139. }
  3141. void CMapXRangeCategory::SetMin(double propVal)
  3142. {
  3143. SetProperty(0x1, VT_R8, propVal);
  3144. }
  3146. double CMapXRangeCategory::GetMax()
  3147. {
  3148. double result;
  3149. GetProperty(0x2, VT_R8, (void*)&result);
  3150. return result;
  3151. }
  3153. void CMapXRangeCategory::SetMax(double propVal)
  3154. {
  3155. SetProperty(0x2, VT_R8, propVal);
  3156. }
  3158. long CMapXRangeCategory::GetNumItems()
  3159. {
  3160. long result;
  3161. GetProperty(0x3, VT_I4, (void*)&result);
  3162. return result;
  3163. }
  3165. CMapXStyle CMapXRangeCategory::GetStyle()
  3166. {
  3167. LPDISPATCH result;
  3168. GetProperty(0x4, VT_DISPATCH, (void*)&result);
  3169. return CMapXStyle(result);
  3170. }
  3172. void CMapXRangeCategory::SetStyle(LPDISPATCH propVal)
  3173. {
  3174. SetProperty(0x4, VT_DISPATCH, propVal);
  3175. }
  3177. /////////////////////////////////////////////////////////////////////////////
  3178. // CMapXRangeCategory operations
  3181. /////////////////////////////////////////////////////////////////////////////
  3182. // CMapXFields properties
  3184. LPENUMVARIANT CMapXFields::GetEnumerator()
  3185. {
  3186. LPENUMVARIANT pEnumVariant = 0;
  3187. LPUNKNOWN pUnknown = 0;
  3188. GetProperty(0xfffffffc, VT_UNKNOWN, (void*)&pUnknown);
  3189. if(pUnknown)
  3190. {
  3191. pUnknown->QueryInterface(IID_IEnumVARIANT, (void**)&pEnumVariant);
  3192. pUnknown->Release();
  3193. }
  3194. return pEnumVariant;
  3195. }
  3197. long CMapXFields::GetCount()
  3198. {
  3199. long result;
  3200. GetProperty(0x1, VT_I4, (void*)&result);
  3201. return result;
  3202. }
  3204. /////////////////////////////////////////////////////////////////////////////
  3205. // CMapXFields operations
  3207. CMapXField CMapXFields::Add(const VARIANT& SourceField, const VARIANT& Name, const VARIANT& AggregationFunction, const VARIANT& Type)
  3208. {
  3209. LPDISPATCH result;
  3210. static BYTE parms[] =
  3211. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3212. InvokeHelper(0x2, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3213. &SourceField, &Name, &AggregationFunction, &Type);
  3214. return CMapXField(result);
  3215. }
  3217. CMapXField CMapXFields::Item(const VARIANT& Index)
  3218. {
  3219. LPDISPATCH result;
  3220. static BYTE parms[] =
  3221. VTS_VARIANT;
  3222. InvokeHelper(0x3, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3223. &Index);
  3224. return CMapXField(result);
  3225. }
  3227. void CMapXFields::Remove(const VARIANT& Index)
  3228. {
  3229. static BYTE parms[] =
  3230. VTS_VARIANT;
  3231. InvokeHelper(0x4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  3232.  &Index);
  3233. }
  3235. void CMapXFields::RemoveAll()
  3236. {
  3237. InvokeHelper(0x5, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  3238. }
  3240. CMapXField CMapXFields::AddStringField(const VARIANT& Name, const VARIANT& Width, const VARIANT& Indexed)
  3241. {
  3242. LPDISPATCH result;
  3243. static BYTE parms[] =
  3244. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3245. InvokeHelper(0x6, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3246. &Name, &Width, &Indexed);
  3247. return CMapXField(result);
  3248. }
  3250. CMapXField CMapXFields::AddLogicalField(const VARIANT& Name, const VARIANT& Indexed)
  3251. {
  3252. LPDISPATCH result;
  3253. static BYTE parms[] =
  3254. VTS_VARIANT VTS_VARIANT;
  3255. InvokeHelper(0x7, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3256. &Name, &Indexed);
  3257. return CMapXField(result);
  3258. }
  3260. CMapXField CMapXFields::AddIntegerField(const VARIANT& Name, const VARIANT& Indexed)
  3261. {
  3262. LPDISPATCH result;
  3263. static BYTE parms[] =
  3264. VTS_VARIANT VTS_VARIANT;
  3265. InvokeHelper(0x8, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3266. &Name, &Indexed);
  3267. return CMapXField(result);
  3268. }
  3270. CMapXField CMapXFields::AddSmallIntField(const VARIANT& Name, const VARIANT& Indexed)
  3271. {
  3272. LPDISPATCH result;
  3273. static BYTE parms[] =
  3274. VTS_VARIANT VTS_VARIANT;
  3275. InvokeHelper(0x9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3276. &Name, &Indexed);
  3277. return CMapXField(result);
  3278. }
  3280. CMapXField CMapXFields::AddNumericField(const VARIANT& Name, const VARIANT& Precision, const VARIANT& Decimals, const VARIANT& Indexed)
  3281. {
  3282. LPDISPATCH result;
  3283. static BYTE parms[] =
  3284. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  3285. InvokeHelper(0xa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3286. &Name, &Precision, &Decimals, &Indexed);
  3287. return CMapXField(result);
  3288. }
  3290. CMapXField CMapXFields::AddFloatField(const VARIANT& Name, const VARIANT& Indexed)
  3291. {
  3292. LPDISPATCH result;
  3293. static BYTE parms[] =
  3294. VTS_VARIANT VTS_VARIANT;
  3295. InvokeHelper(0xb, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3296. &Name, &Indexed);
  3297. return CMapXField(result);
  3298. }
  3300. CMapXField CMapXFields::AddDateField(const VARIANT& Name, const VARIANT& Indexed)
  3301. {
  3302. LPDISPATCH result;
  3303. static BYTE parms[] =
  3304. VTS_VARIANT VTS_VARIANT;
  3305. InvokeHelper(0xc, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  3306. &Name, &Indexed);
  3307. return CMapXField(result);
  3308. }
  3311. /////////////////////////////////////////////////////////////////////////////
  3312. // COleFont properties
  3314. CString COleFont::GetName()
  3315. {
  3316. CString result;
  3317. GetProperty(0x0, VT_BSTR, (void*)&result);
  3318. return result;
  3319. }
  3321. void COleFont::SetName(LPCTSTR propVal)
  3322. {
  3323. SetProperty(0x0, VT_BSTR, propVal);
  3324. }
  3326. CY COleFont::GetSize()
  3327. {
  3328. CY result;
  3329. GetProperty(0x2, VT_CY, (void*)&result);
  3330. return result;
  3331. }
  3333. void COleFont::SetSize(const CY& propVal)
  3334. {
  3335. SetProperty(0x2, VT_CY, &propVal);
  3336. }
  3338. BOOL COleFont::GetBold()
  3339. {
  3340. BOOL result;
  3341. GetProperty(0x3, VT_BOOL, (void*)&result);
  3342. return result;
  3343. }
  3345. void COleFont::SetBold(BOOL propVal)
  3346. {
  3347. SetProperty(0x3, VT_BOOL, propVal);
  3348. }
  3350. BOOL COleFont::GetItalic()
  3351. {
  3352. BOOL result;
  3353. GetProperty(0x4, VT_BOOL, (void*)&result);
  3354. return result;
  3355. }
  3357. void COleFont::SetItalic(BOOL propVal)
  3358. {
  3359. SetProperty(0x4, VT_BOOL, propVal);
  3360. }
  3362. BOOL COleFont::GetUnderline()
  3363. {
  3364. BOOL result;
  3365. GetProperty(0x5, VT_BOOL, (void*)&result);
  3366. return result;
  3367. }
  3369. void COleFont::SetUnderline(BOOL propVal)
  3370. {
  3371. SetProperty(0x5, VT_BOOL, propVal);
  3372. }
  3374. BOOL COleFont::GetStrikethrough()
  3375. {
  3376. BOOL result;
  3377. GetProperty(0x6, VT_BOOL, (void*)&result);
  3378. return result;
  3379. }
  3381. void COleFont::SetStrikethrough(BOOL propVal)
  3382. {
  3383. SetProperty(0x6, VT_BOOL, propVal);
  3384. }
  3386. short COleFont::GetWeight()
  3387. {
  3388. short result;
  3389. GetProperty(0x7, VT_I2, (void*)&result);
  3390. return result;
  3391. }
  3393. void COleFont::SetWeight(short propVal)
  3394. {
  3395. SetProperty(0x7, VT_I2, propVal);
  3396. }
  3398. short COleFont::GetCharset()
  3399. {
  3400. short result;
  3401. GetProperty(0x8, VT_I2, (void*)&result);
  3402. return result;
  3403. }
  3405. void COleFont::SetCharset(short propVal)
  3406. {
  3407. SetProperty(0x8, VT_I2, propVal);
  3408. }
  3410. /////////////////////////////////////////////////////////////////////////////
  3411. // COleFont operations
  3413. /////////////////////////////////////////////////////////////////////////////
  3414. // CMapXStyle properties
  3416. short CMapXStyle::GetSymbolCharacter()
  3417. {
  3418. short result;
  3419. GetProperty(0x1, VT_I2, (void*)&result);
  3420. return result;
  3421. }
  3423. void CMapXStyle::SetSymbolCharacter(short propVal)
  3424. {
  3425. SetProperty(0x1, VT_I2, propVal);
  3426. }
  3428. unsigned long CMapXStyle::GetLineColor()
  3429. {
  3430. unsigned long result;