MAPX.H
上传用户:gulin912
上传日期:2022-08-10
资源大小:330k
文件大小:107k
源码类别:

GIS编程

开发平台:

Visual C++

  1. #ifndef __MAPX_H__
  2. #define __MAPX_H__
  3. #ifdef UNDER_CE
  4. #define HELP_FINDER       0x000b
  5. #endif
  6. #pragma warning( disable: 4100)
  7. // event dispids
  8. #define MAPX_DISPID_SELECTION_CHANGED 0x1
  9. #define MAPX_DISPID_RESOLVEDATABIND 0x2
  10. #define MAPX_DISPID_TOOLUSED 0x3
  11. #define MAPX_DISPID_REQUESTDATA 0x4
  12. #define MAPX_DISPID_DATAMISMATCH 0x5
  13. #define MAPX_DISPID_MAPVIEWCHANGED 0x6
  14. #define MAPX_DISPID_ANNOTATIONADDED 0x7
  15. #define MAPX_DISPID_ANNOTATIONCHANGED 0x8
  16. #define MAPX_DISPID_THEMEMODIFYREQUESTED 0x9
  17. #define MAPX_DISPID_DRAWUSERLAYER 0x0a
  18. #define MAPX_DISPID_POLYTOOLUSED 0x0b
  19. #define MAPX_DISPID_MOUSEWHEEL 0x0c
  20. #define MAPX_DISPID_MAPINITIALIZED 0x0d
  21. #define MAPX_DISPID_RESOLVEDATABINDEX 0xe
  22. #define MAPX_DISPID_MAPDRAW 0xf
  23. // dispatch id definitions for ole stock events are
  24. // defined in <olectl.h>
  25. // they are included here for reference
  26. //#define DISPID_CLICK                    (-600)
  27. //#define DISPID_DBLCLICK                 (-601)
  28. //#define DISPID_KEYDOWN                  (-602)
  29. //#define DISPID_KEYPRESS                 (-603)
  30. //#define DISPID_KEYUP                    (-604)
  31. //#define DISPID_MOUSEDOWN                (-605)
  32. //#define DISPID_MOUSEMOVE                (-606)
  33. //#define DISPID_MOUSEUP                  (-607)
  34. //#define DISPID_ERROREVENT               (-608)
  35. // enum definitions to match typelib
  36. enum ToolConstants
  37. {
  38. miArrowTool = 1000,
  39. miPanTool = 1001,
  40. miCenterTool = 1002,
  41. miZoomInTool = 1003,
  42. miZoomOutTool = 1004,
  43. miSymbolTool = 1005,
  44. miTextTool = 1006,
  45. miSelectTool = 1007,
  46. miRadiusSelectTool = 1008,
  47. miRectSelectTool = 1009,
  48. miPolygonSelectTool = 1010,
  49. miLabelTool = 1011,
  50. miAddLineTool = 1012,
  51. miAddPolylineTool = 1013,
  52. miAddRegionTool = 1014,
  53. miAddPointTool = 1015
  54. };
  55. /* Synchronize this with mimoapp.odl! */
  56. enum CursorConstants
  57. {
  58. miDefaultCursor = 0,
  59. miArrowCursor = 1,
  60. miCrossCursor = 2,
  61. miIBeamCursor = 3,
  62. miIconCursor = 4,
  63. miSizeCursor = 5,
  64. miSizeNESWCursor = 6,
  65. miSizeNSCursor = 7,
  66. miSizeNWSECursor = 8,
  67. miSizeEWCursor = 9,
  68. miUpArrowCursor = 10,
  69. miHourglassCursor = 11,
  70. miNoDropCursor = 12,
  71. miArrowHourglassCursor = 13,
  72. miArrowQuestionCursor = 14,
  73. miSizeAllCursor = 15,
  74. miArrowToolCursor = 16,
  75. miPanCursor = 17,
  76. miCenterCursor = 18,
  77. miZoomInCursor = 19,
  78. miZoomOutCursor = 20,
  79. miSymbolCursor = 21,
  80. miTextCursor = 22,
  81. miSelectCursor = 23,
  82. miRadiusSelectCursor = 24,
  83. miRectSelectCursor = 25,
  84. miRegionSelectCursor = 26,
  85. miInfoCursor = 27,
  86. miSelectPlusCursor = 28,
  87. miSelectRadiusPlusCursor = 29,
  88. miSelectRectPlusCursor = 30,
  89. miSelectRegionPlusCursor = 31,
  90. miSelectMinusCursor = 32,
  91. miSelectRadiusMinusCursor = 33,
  92. miSelectRectMinusCursor = 34,
  93. miSelectRegionMinusCursor = 35,
  94. miLabelCursor = 36,
  95. miDrilldownExpandCursor = 37,
  96. miDrilldownContractCursor = 38,
  97. miInfoCursorOld = 39,
  98. miCustomCursor = 40
  99. };
  100. enum MapUnitConstants
  101. {
  102. miUnitMile = 0,
  103. miUnitKilometer = 1,
  104. miUnitInch = 2,
  105. miUnitFoot = 3,
  106. miUnitYard = 4,
  107. miUnitMillimeter = 5,
  108. miUnitCentimeter = 6,
  109. miUnitMeter = 7,
  110. miUnitSurveyFoot = 8,
  111. miUnitNauticalMile = 9,
  112. miUnitTwip = 10,
  113. miUnitPoint = 11,
  114. miUnitPica = 12,
  115. miUnitDegree = 13,
  116. miUnitLink = 30,
  117. miUnitChain = 31,
  118. miUnitRod = 32
  119. };
  120. enum PaperUnitConstants
  121. {
  122. miPaperUnitMile = 0,
  123. miPaperUnitKilometer = 1,
  124. miPaperUnitInch = 2,
  125. miPaperUnitFoot = 3,
  126. miPaperUnitYard = 4,
  127. miPaperUnitMillimeter = 5,
  128. miPaperUnitCentimeter = 6,
  129. miPaperUnitMeter = 7,
  130. miPaperUnitSurveyFoot = 8,
  131. miPaperUnitNauticalMile = 9,
  132. miPaperUnitTwip = 10,
  133. miPaperUnitPoint = 11,
  134. miPaperUnitPica = 12,
  135. miPaperUnitDegree = 13,
  136. miPaperUnitLink = 30,
  137. miPaperUnitChain = 31,
  138. miPaperUnitRod = 32
  139. };
  140. enum SelectionTypeConstants
  141. {
  142. miSelectionNew = 0,
  143. miSelectionAppend = 1,
  144. miSelectionRemove = 2
  145. };
  146. enum ConversionConstants
  147. {
  148. miMapToScreen = 0,
  149. miScreenToMap = 1
  150. };
  151. enum DotSizeConstants
  152. {
  153. miDotSizeSmall = 0,
  154. miDotSizeLarge = 1
  155. };
  156. enum DistribMethodConstants
  157. {
  158. miCustomRanges = 0,
  159. miEqualCountPerRange = 1,
  160. miEqualRangeSize = 2,
  161. miNaturalBreak = 3,
  162. miStandardDeviation = 4
  163. };
  164. enum PenStyleConstants
  165. {
  166. miPenNone = 0,
  167. miPenSolid = 1
  168. };
  169. enum FieldTypeConstants
  170. {
  171. miTypeString = 0,
  172. miTypeNumeric = 1,
  173. miTypeDate = 2,
  174. miTypeInteger = 3,
  175. miTypeSmallInt = 4,
  176. miTypeFloat = 5,
  177. miTypeLogical = 6
  178. };
  179. enum AggregationFunctionConstants
  180. {
  181. miAggregationSum = 0,
  182. miAggregationAverage = 1,
  183. miAggregationCount = 2,
  184. miAggregationIndividual = 4,
  185. miAggregationAuto = 5
  186. };
  187. enum FillPatternConstants
  188. {
  189. miPatternNoFill = 0,
  190. miPatternHollow = 1,
  191. miPatternSolid = 2,
  192. miPatternHorizontal = 3,
  193. miPatternVertical = 4,
  194. miPatternFDiag = 5,
  195. miPatternFilBDiag = 6,
  196. miPatternCross = 7,
  197. miPatternDiagCross = 8
  198. };
  199. enum ThemeTypeConstants
  200. {
  201. miThemeRanged = 0,
  202. miThemeBarChart = 1,
  203. miThemePieChart = 2,
  204. miThemeGradSymbol = 3,
  205. miThemeDotDensity = 4,
  206. miThemeIndividualValue = 5,
  207. miThemeAuto = 6,
  208. miThemeLabelRanged = 7,
  209. miThemeLabelIndividualValue = 8,
  210. miThemeNone = 9,
  211. };
  212. enum AnnotationTypeConstants
  213. {
  214. miSymbolAnnotation = 1,
  215. miTextAnnotation = 6,
  216. };
  217. enum ToolTypeConstants
  218. {
  219. miToolTypePoint = 0,
  220. miToolTypeLine = 1,
  221. miToolTypeCircle = 2,
  222. miToolTypeMarquee = 3,
  223. miToolTypePoly = 4,
  224. miToolTypePolygon = 5
  225. };
  226. enum PolyToolFlagConstants
  227. {
  228. miPolyToolBegin = 0,
  229. miPolyToolEnd = 1,
  230. miPolyToolEndEscaped = 2,
  231. miPolyToolInProgress = 3
  232. };
  233. enum DatasetTypeConstants
  234. {
  235. miDataSetDAO = 1,
  236. miDataSetODBC = 2,
  237. miDataSetUnbound = 3,
  238. miDataSetGlobalHandle = 4,
  239. miDataSetOLEData = 5,
  240. miDataSetLayer = 6,
  241. miDataSetNotesView = 7,
  242. miDataSetNotesQuery = 8,
  243. miDataSetSafeArray = 9,
  244. //miDataSetOEO = 10,
  245. miDataSetDelphi = 1010,
  246. miDataSetDelphi4 = 1011,
  247. miDataSetDelphi5 = 1012,
  248. miDataSetADO = 12,
  249. miDataSetRDO = 13,
  250. miDataSetXML = 14,
  251. miDataSetOCI = 15
  252. };
  253. enum AnnotationChangedTypeConstants
  254. {
  255. miAddAnnotation = 0,
  256. miDeleteAnnotation = 1,
  257. miSelectAnnotation = 2,
  258. miEditAnnotation = 3
  259. };
  260. enum ResolveDataBindConstants
  261. {
  262. miChooseField = 0,
  263. miChooseLayer = 1,
  264. miChooseGeoSet = 2
  265. };
  266. enum SpreadByConstants
  267. {
  268. miSpreadByNone = 0,
  269. miSpreadByColor = 1,
  270. miSpreadBySize = 2
  271. };
  272. enum BindLayerTypeConstants
  273. {
  274. miBindLayerTypeNormal = 0,
  275. miBindLayerTypeXY = 1,
  276. miBindLayerTypePointRef = 2
  277. };
  278. enum ExportFormatConstants
  279. {
  280. miFormatWMF = 0,
  281. miFormatBMP = 1,
  282. miFormatGIF = 2,
  283. miFormatJPEG = 3,
  284. miFormatTIF = 4,
  285. miFormatPNG = 5,
  286. miFormatPSD = 6
  287. };
  288. enum FeatureTypeConstants
  289. {
  290. miFeatureTypeRegion = 0,
  291. miFeatureTypeLine = 1,
  292. miFeatureTypeSymbol = 2,
  293. miFeatureTypeMixed = 3,
  294. miFeatureTypeUnknown = 4,
  295. miFeatureTypeText = 5,
  296. miFeatureTypeNull = 6,
  297. miFeatureTypeMultipoint = 7,
  298. miFeatureTypeCollection = 8
  299. };
  300. enum LineTypeConstants
  301. {
  302. miLineTypeNone = 0,
  303. miLineTypeSimple = 1,
  304. miLineTypeArrow = 2
  305. };
  306. enum PositionConstants
  307. {
  308. miPositionCC = 0,
  309. miPositionTL = 1,
  310. miPositionTC = 2,
  311. miPositionTR = 3,
  312. miPositionCL = 4,
  313. miPositionCR = 5,
  314. miPositionBL = 6,
  315. miPositionBC = 7,
  316. miPositionBR = 8
  317. };
  318. enum SearchTypeConstants
  319. {
  320. miSearchTypeCentroidWithin = 0,
  321. miSearchTypePartiallyWithin = 1,
  322. miSearchTypeEntirelyWithin = 2
  323. };
  324. enum LayerTypeConstants
  325. {
  326. miLayerTypeNormal = 0,
  327. miLayerTypeRaster = 2,
  328. miLayerTypeSeamless = 4,
  329. miLayerTypeUnknown = 5,
  330. miLayerTypeUserDraw = 6,
  331. miLayerTypeDrilldown = 7,
  332. };
  333. enum AreaUnitConstants
  334. {
  335. miUnitSquareMile = 14,
  336. miUnitSquareKilometer = 15,
  337. miUnitSquareInch = 16,
  338. miUnitSquareFoot = 17,
  339. miUnitSquareYard = 18,
  340. miUnitSquareMillimeter = 19,
  341. miUnitSquareCentimeter = 20,
  342. miUnitSquareMeter = 21,
  343. miUnitSquareSurveyFoot = 22,
  344. miUnitSquareNauticalMile = 23,
  345. miUnitSquareTwip = 24,
  346. miUnitSquarePoint = 25,
  347. miUnitSquarePica = 26,
  348. miUnitSquareDegree = 27,
  349. miUnitAcre = 28,
  350. miUnitHectare = 29,
  351. miUnitSquareLink = 33,
  352. miUnitSquareChain = 34,
  353. miUnitSquareRod = 35,
  354. miUnitPerch = 36,
  355. miUnitRood = 37
  356. };
  357. enum CircleTypeConstants
  358. {
  359. miCircleTypeScreen= 0,
  360. miCircleTypeMap = 1,
  361. };
  362. enum CoordSysTypeConstants
  363. {
  364. miNonEarth = 0,
  365. miLongLat = 1,
  366. miCylindricalEqualArea = 2,
  367. miLambertConformalConic = 3,
  368. miLambertAzimuthalEqualArea = 4,
  369. miAzimuthalEquidistant = 5,
  370. miEquidistantConic = 6,
  371. miHotineObliqueMercator = 7,
  372. miTransverseMercator = 8,
  373. miAlbersEqualAreaConic = 9,
  374. miMercator = 10,
  375. miMillerCylindrical = 11,
  376. miRobinson = 12,
  377. miMollweide = 13,
  378. miEckertIV = 14,
  379. miEckertVI = 15,
  380. miSinusoidal = 16,
  381. miGall = 17,
  382. miNewZealandMapGrid = 18,
  383. miLambertConformalConicBelgium = 19,
  384. miStereographic = 20,
  385. miTransverseMercatorDenmarkS34J = 21,
  386. miTransverseMercatorDenmarkS34S = 22,
  387. miTransverseMercatorDenmarkS45B = 23,
  388. miTransverseMercatorFinland = 24,
  389. miSwissObliqueMercator = 25,
  390. miMercatorStdParallel = 26,
  391. miPolyconic = 27,
  392. miAzimuthalEquidistantOblique = 28,
  393. miLambertAzimuthalEqualAreaOblique = 29,
  394. miCassiniSoldner = 30
  395. };
  396. enum SymbolTypeConstants
  397. {
  398. miSymbolTypeTrueTypeFont = 0,
  399. miSymbolTypeBitmap = 1,
  400. miSymbolTypeVector = 2
  401. };
  402. enum ColorConstants
  403. {
  404. miColorBlack = 0,
  405. miColorRed = 255,
  406. miColorGreen = 65280,
  407. miColorBlue = 16711680,
  408. miColorMagenta = 16711935,
  409. miColorCyan = 16776960,
  410. miColorWhite = 16777215,
  411. miColorLightGray = 12632256,
  412. miColorDarkGray = 4210752,
  413. miColorGray = 8421504,
  414. miColorPaleYellow = 13697023,
  415. miColorLightYellow = 8454143,
  416. miColorYellow = 65535,
  417. miColorLimeGreen = 12639424,
  418. miColorTeal = 8421440,
  419. miColorDarkGreen = 16384,
  420. miColorMaroon = 128,
  421. miColorPurple = 8388736,
  422. miColorOrange = 33023,
  423. miColorKhaki = 7051175,
  424. miColorOlive = 32896,
  425. miColorBrown = 4210816,
  426. miColorNavy = 8404992,
  427. miColorScrollBars = 0x80000000,
  428. miColorDesktop = 0x80000001,
  429. miColorActiveTitleBar = 0x80000002,
  430. miColorInactiveTitleBar = 0x80000003,
  431. miColorMenuBar = 0x80000004,
  432. miColorWindowBackground = 0x80000005,
  433. miColorWindowFrame = 0x80000006,
  434. miColorMenuText = 0x80000007,
  435. miColorWindowText = 0x80000008,
  436. miColorTitleBarText = 0x80000009,
  437. miColorActiveBorder = 0x8000000A,
  438. miColorInactiveBorder = 0x8000000B,
  439. miColorApplicationWorkspace = 0x8000000C,
  440. miColorHighlight = 0x8000000D,
  441. miColorHighlightText = 0x8000000E,
  442. miColorButtonFace = 0x8000000F,
  443. miColorButtonShadow = 0x80000010,
  444. miColorGrayText = 0x80000011,
  445. miColorButtonText = 0x80000012,
  446. miColorInactiveCaptionText = 0x80000013,
  447. miColor3DHighlight = 0x80000014,
  448. miColor3DDarkShadow = 0x80000015,
  449. miColor3DLight = 0x80000016,
  450. miColorInfoText = 0x80000017,
  451. miColorInfoBackground = 0x80000018,
  452. };
  453. enum IntersectionTestConstants
  454. {
  455. miIntersectCentroidWithinFeature = 0,
  456. miIntersectFeature = 1,
  457. miIntersectEntirelyWithinFeature = 2
  458. };
  459. enum IntersectionPointConstants
  460. {
  461. miIntersectCrossings = 9,
  462. miIntersectCommon = 10,
  463. miIntersectAll = 11
  464. };
  465. enum MousewheelSupportConstants
  466. {
  467. miNoMousewheelSupport = 1,
  468. miMousewheelNoAutoScroll = 2,
  469. miFullMousewheelSupport = 3
  470. };
  471. enum StyleUnitConstants
  472. {
  473. miStyleUnitPixel = 0,
  474. miStyleUnitTenthsOfPoint = 1
  475. };
  476. enum ServerLayerOptions // bit mask for long, must be power of 2
  477. {
  478. miLayerCacheOn = 0, // default = Cache on
  479. miLayerMBRSearchOn = 0, // default = Search on
  480. miLayerCacheOff = 1,
  481. miMBRSearchOff  = 2
  482. };
  483. enum LayerBeginAccessConstants
  484. {
  485. miAccessRead= 0,
  486. miAccessReadWrite = 1,
  487. };
  488. enum LayerEndAccessConstants
  489. {
  490. miAccessEnd= 0,
  491. };
  492. enum GraduationConstants
  493. {
  494. miGraduateBySquareRoot = 0,
  495. miGraduateByConstant = 1,
  496. miGraduateByLogarithm = 2
  497. };
  498. enum LayerInfoTypeConstants
  499. {
  500. miLayerInfoTypeTab = 0,
  501. miLayerInfoTypeUserDraw = 1,
  502. miLayerInfoTypeRaster = 2,
  503. miLayerInfoTypeShape = 3,
  504. miLayerInfoTypeServer = 4,
  505. miLayerInfoTypeGeodictUserName = 5,
  506. miLayerInfoTypeTemp = 6,
  507. miLayerInfoTypeNewTable = 7
  508. };
  509. enum MapDrawConstants
  510. {
  511. miDrawBegin = 1,
  512. miDrawEnd = 2
  513. };
  514. enum ColorSpreadingMethodConstants
  515. {
  516. miColorMethodRGB = 0,
  517. miColorMethodHSV = 1
  518. };
  519. enum ApplyAttributeConstants
  520. {
  521. miApplyAttributeAll = 0,
  522. miApplyAttributeColor = 1,
  523. miApplyAttributeSize = 2
  524. };
  525. enum ToolFlagConstants
  526. {
  527. miToolBegin = 0,
  528. miToolEnd = 1,
  529. miToolEndEscaped = 2,
  530. miToolInProgress = 3,
  531. miToolCompleted = 4
  532. };
  533. enum FeatureEditModeConstants
  534. {
  535. miEditModeFeature = 1,
  536. miEditModeNode = 2,
  537. miMoveDuplicateNodes = 4,
  538. miDeleteDuplicateNodes = 8,
  539. miEditModeAddNode = 64
  540. };
  541. enum SearchResultTypeConstants
  542. {
  543. miSearchResultAll = 0x0000,
  544. miSearchResultTopmost = 0x0001,
  545. miSearchResultRegion = 0x0002,
  546. miSearchResultPoint = 0x0004,
  547. miSearchResultLine = 0x0008,
  548. miSearchResultText = 0x0010,
  549. miSearchResultMultipoint= 0x0020,
  550. miSearchResultCollection= 0x0040
  551. };
  552. // forward delcarations
  553. class CMapXAnnotation;
  554. class CMapXAnnotations;
  555. class CMapXBitmapSymbol;
  556. class CMapXBitmapSymbols;
  557. class CMapXCoordSys;
  558. class CMapXDataset;
  559. class CMapXDatasets;
  560. class CMapXFeature;
  561. class CMapXFeatureFactory;
  562. class CMapXFeatures;
  563. class CMapXField;
  564. class CMapXFields;
  565. class CMapXFindFeature;
  566. class CMapXFindMatch;
  567. class CMapXFindMatches;
  568. class CMapXFindResult;
  569. class CMapXGeoset;
  570. class CMapXGeosets;
  571. class CMapXGraphic;
  572. class CMapXIndividualValueCategories;
  573. class CMapXIndividualValueCategory;
  574. class CMapXLabelProperties;
  575. class CMapXLayer;
  576. class CMapXLayerFind;
  577. class CMapXLayerInfo;
  578. class CMapXLayers;
  579. class CMapXLegend;
  580. class CMapXLegendText;
  581. class CMapXLegendTexts;
  582. class CMapXMultivarCategories;
  583. class CMapXMultivarCategory;
  584. class CMapXParts;
  585. class CMapXPoint;
  586. class CMapXPoints;
  587. class CMapXRangeCategories;
  588. class CMapXRangeCategory;
  589. class CMapXRectangle;
  590. class CMapXResolveObject;
  591. class CMapXResolveObjects;
  592. class CMapXRowValue;
  593. class CMapXRowValues;
  594. class CMapXSelection;
  595. class CMapXSourceRow;
  596. class CMapXSourceRows;
  597. class CMapXStyle;
  598. class CMapXTheme;
  599. class CMapXThemeProperties;
  600. class CMapXThemes;
  601. class CMapXTitle;
  602. class CMapXVariable;
  603. class CMapXVariables;
  604. class COptionalVariant;
  605. CLSID GetClassID(LPCTSTR pszProgramID);
  606. // simple class to pass to methods that take
  607. // a variant that we want to mark as optional (not supplied by the method call)
  608. class COptionalVariant: public COleVariant
  609. {
  610. public:
  611. COptionalVariant() { vt = VT_ERROR; scode = DISP_E_PARAMNOTFOUND; }
  612. };
  613. // another helper class to handle dispatch variants
  614. class COleVariantDispatch: public COleVariant
  615. {
  616. public:
  617. COleVariantDispatch(LPDISPATCH pdisp)
  618. {
  619.     vt = VT_DISPATCH;
  620.     pdispVal = pdisp;
  621. pdispVal->AddRef();
  622. }
  623. };
  624. // This is the MapX major version being used:
  625. #define MAPX_VERSION _T("5")
  626. // MapX program IDs' prefix:
  627. #if defined(MAPX_MOBILE) || defined(UNDER_CE)
  628. #define MAPX_PROGRAM_ID_PREFIX _T("MapXMobile")
  629. #else
  630. #define MAPX_PROGRAM_ID_PREFIX _T("MapX")
  631. #endif
  632. // to derive CMapX from COleDispatchDriver instead of CWnd,
  633. // comment out the next line
  634. #define CWND_MAPX
  635. /////////////////////////////////////////////////////////////////////////////
  636. // CMapX wrapper class
  637. #ifdef CWND_MAPX
  638. //----------------------------
  639. class CMapX : public CWnd
  640. {
  641. protected:
  642. DECLARE_DYNCREATE(CMapX)
  643. public:
  644. virtual BOOL Create(LPCTSTR lpszClassName,
  645. LPCTSTR lpszWindowName, DWORD dwStyle,
  646. const RECT& rect,
  647. CWnd* pParentWnd, UINT nID,
  648. CCreateContext* pContext = NULL)
  649. { return CreateControl(GetClsid(), lpszWindowName, dwStyle, rect, pParentWnd, nID); }
  650. BOOL Create(LPCTSTR lpszWindowName, DWORD dwStyle,
  651. const RECT& rect, CWnd* pParentWnd, UINT nID,
  652. CFile* pPersist = NULL, BOOL bStorage = FALSE,
  653. BSTR bstrLicKey = NULL)
  654. { return CreateControl(GetClsid(), lpszWindowName, dwStyle, rect, pParentWnd, nID,
  655. pPersist, bStorage, bstrLicKey); }
  656. #else
  657. class CMapX : public COleDispatchDriver
  658. {
  659. #endif //of #ifdef CWND_MAPX
  660. public:
  661. const CLSID& GetClsid() const
  662. {
  663. static bool bInitialized = false;
  664. static CLSID clsid;
  665. if(!bInitialized)
  666. {
  667. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Map.") MAPX_VERSION);
  668. bInitialized = true;
  669. }
  670. return clsid;
  671. }
  672. // default bAddRef is false because you don't need to addref
  673. // when passing result to Feature.Attach();
  674. LPDISPATCH GetDispatch(BOOL bAddRef=FALSE);
  675. // Attributes
  676. public:
  677. CString GetDataSetGeoField();
  678. void SetDataSetGeoField(LPCTSTR);
  679. CString GetVersion();
  680. OLE_HANDLE GetHWnd();
  681. CMapXAnnotations GetAnnotations();
  682. CMapXLayers GetLayers();
  683. BOOL GetAutoRedraw();
  684. void SetAutoRedraw(BOOL);
  685. double GetZoom();
  686. void SetZoom(double);
  687. double GetCenterX();
  688. void SetCenterX(double);
  689. double GetCenterY();
  690. void SetCenterY(double);
  691. CString GetGeoSet();
  692. void SetGeoSet(LPCTSTR);
  693. double GetGeoSetWidth();
  694. double GetMapPaperHeight();
  695. double GetMapPaperWidth();
  696. short GetMaxSearchTime();
  697. void SetMaxSearchTime(short);
  698. long GetPaperUnit();
  699. void SetPaperUnit(long);
  700. BOOL GetPreferCompactLegends();
  701. void SetPreferCompactLegends(BOOL);
  702. CMapXStyle GetDefaultStyle();
  703. void SetDefaultStyle(LPDISPATCH);
  704. CString GetGeoDictionary();
  705. // this method currently will not work in 'run' mode. which
  706. // is the only mode MFC Control containers support, so don't bother calling it.
  707. void SetGeoDictionary(LPCTSTR);
  708. long GetDataSetTheme();
  709. void SetDataSetTheme(long);
  710. long GetCurrentTool();
  711. void SetCurrentTool(long);
  712. long GetMousePointer();
  713. void SetMousePointer(long);
  714. CMapXDatasets GetDatasets();
  715. CMapXTitle GetTitle();
  716. CString GetTitleText();
  717. void SetTitleText(LPCTSTR);
  718. long GetMapUnit();
  719. void SetMapUnit(long);
  720. double GetRotation();
  721. void SetRotation(double);
  722. CMapXGeosets GetGeosets();
  723. long GetAreaUnit();
  724. void SetAreaUnit(long);
  725. CMapXRectangle GetBounds();
  726. void SetBounds(LPDISPATCH);
  727. CMapXCoordSys GetDisplayCoordSys();
  728. void SetDisplayCoordSys(LPDISPATCH);
  729. CMapXCoordSys GetNumericCoordSys();
  730. void SetNumericCoordSys(LPDISPATCH);
  731. BOOL GetExportSelection();
  732. void SetExportSelection(BOOL);
  733. CMapXStyle GetSelectionStyle();
  734. void SetSelectionStyle(LPDISPATCH);
  735. CMapXFeatureFactory GetFeatureFactory();
  736. long GetDefaultConversionResolution();
  737. void SetDefaultConversionResolution(long);
  738. OLE_COLOR GetBackColor();
  739. void SetBackColor(OLE_COLOR);
  740. long GetMousewheelSupport();
  741. void SetMousewheelSupport(long);
  742. BOOL GetMatchNumericFields();
  743. void SetMatchNumericFields(BOOL);
  744. double GetMapScreenWidth();
  745. double GetMapScreenHeight();
  746. long GetRedrawInterval();
  747. void SetRedrawInterval(long l);
  748. CString GetSearchPath();
  749. void SetSearchPath(LPCTSTR propVal);
  750. short GetMatchThreshold();
  751. void SetMatchThreshold(short l);
  752. BOOL GetWaitCursorEnabled();
  753. void SetWaitCursorEnabled(BOOL b);
  754. BOOL GetPanAnimationLayer();
  755. void SetPanAnimationLayer(BOOL b);
  756. long GetInfotipPopupDelay();
  757. void SetInfotipPopupDelay(long propVal);
  758. CString GetMouseIcon();
  759. void SetMouseIcon(LPCTSTR propVal);
  760. BOOL GetInfotipSupport();
  761. void SetInfotipSupport(BOOL b);
  762. short GetFeatureEditMode();
  763. void SetFeatureEditMode(short);
  764. long GetCheckEscapeKeyInterval();
  765. void SetCheckEscapeKeyInterval(long);
  766. BOOL GetSnapToNodeSupport();
  767. void SetSnapToNodeSupport(BOOL b);
  768. short GetSnapTolerance();
  769. void SetSnapTolerance(short);
  770. BOOL GetDynamicSelectionSupport();
  771. void SetDynamicSelectionSupport(BOOL b);
  772. // Operations
  773. public:
  774. void ConvertCoord(float* ScreenX, float* ScreenY, double* MapX, double* MapY, short Direction);
  775. void ZoomTo(double Zoom, double X, double Y);
  776. void CreateCustomTool(short ToolNumber, short Type, const VARIANT& Cursor, const VARIANT& ShiftCursor, const VARIANT& CtrlCursor, const VARIANT& bInfoTips);
  777. void CreateCustomTool(short ToolNumber, short Type, short Cursor)
  778. { CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COptionalVariant(), COptionalVariant(), COptionalVariant()); }
  779. void CreateCustomTool(short ToolNumber, short Type, LPCTSTR Cursor)
  780. { CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COptionalVariant(), COptionalVariant(), COptionalVariant()); }
  781. void CreateCustomTool(short ToolNumber, short Type, short Cursor, bool bInfoTips)
  782. {
  783. short sInfoTips = (short) bInfoTips;
  784. CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COptionalVariant(), COptionalVariant(), COleVariant(sInfoTips));
  785. }
  786. void CreateCustomTool(short ToolNumber, short Type, LPCTSTR Cursor, bool bInfoTips)
  787. {
  788. short sInfoTips = (short) bInfoTips;
  789. CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COptionalVariant(), COptionalVariant(), COleVariant(sInfoTips));
  790. }
  791. void CreateCustomTool(short ToolNumber, short Type, short Cursor, short ShiftCursor, short CtrlCursor)
  792. { CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COleVariant(ShiftCursor), COleVariant(CtrlCursor), COptionalVariant()); }
  793. void CreateCustomTool(short ToolNumber, short Type, LPCTSTR Cursor, LPCTSTR ShiftCursor, LPCTSTR CtrlCursor)
  794. { CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COleVariant(ShiftCursor), COleVariant(CtrlCursor), COptionalVariant()); }
  795. void CreateCustomTool(short ToolNumber, short Type, short Cursor, short ShiftCursor, short CtrlCursor, bool bInfoTips)
  796. {
  797. short sInfoTips = (short) bInfoTips;
  798. CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COleVariant(ShiftCursor), COleVariant(CtrlCursor), COleVariant(sInfoTips));
  799. }
  800. void CreateCustomTool(short ToolNumber, short Type, LPCTSTR Cursor, LPCTSTR ShiftCursor, LPCTSTR CtrlCursor, bool bInfoTips)
  801. {
  802. short sInfoTips = (short) bInfoTips;
  803. CreateCustomTool(ToolNumber, Type, COleVariant(Cursor), COleVariant(ShiftCursor), COleVariant(CtrlCursor), COleVariant(sInfoTips));
  804. }
  805. double Distance(double X1, double Y1, double X2, double Y2);
  806. void Refresh();
  807. void PrintMap(long hDC, long X, long Y, long W, long H);
  808. void ExportMap(LPCTSTR Destination, short Format, const VARIANT& Width, const VARIANT& Height);
  809. void ExportMap(LPCTSTR Destination, short Format)
  810. { ExportMap(Destination, Format, COptionalVariant(), COptionalVariant()); }
  811. void ExportMap(LPCTSTR Destination, short Format, double Width, double Height)
  812. { ExportMap(Destination, Format, COleVariant(Width), COleVariant(Height)); }
  813. void PropertyPage();
  814. void ConvertCoordV(VARIANT* ScreenX, VARIANT* ScreenY, VARIANT* MapX, VARIANT* MapY, short Direction);
  815. void SetSize(long Width, long Height);
  816. BOOL IsPointVisible(double X, double Y);
  817. BOOL ClipLine(double* X1, double* Y1, double* X2, double* Y2);
  818. BOOL ClipLineV(VARIANT* X1, VARIANT* Y1, VARIANT* X2, VARIANT* Y2);
  819. void SaveMapAsGeoset(LPCTSTR Name, LPCTSTR Filespec);
  820. void Pan(float ScreenX, float ScreenY);
  821. void AboutBox();
  822. };
  823. // EVENT Prototypes
  824. // For dispatch objects passed to events, the event handler should not change the reference count
  825. // ie: do not call release on the object because an ocx does not do an addref before passing the
  826. // object to the event
  827. /*
  828. void Click();
  829. void DblClick();
  830. void Error(short Number, BSTR* Description, long Scode, LPCTSTR Source, LPCTSTR HelpFile, long HelpContext, BOOL* CancelDisplay);
  831. void KeyDown(short* KeyCode, short Shift);
  832. void KeyPress(short* KeyAscii);
  833. void KeyUp(short* KeyCode, short Shift);
  834. void MouseMove(short Button, short Shift, float X, float Y);
  835. void MouseDown(short Button, short Shift, float X, float Y);
  836. void MouseUp(short Button, short Shift, float X, float Y);
  837. void SelectionChanged();
  838. void ResolveDataBind(short Flag, short NumMatches, const VARIANT& Matches, short* Choice, BOOL* Cancel);
  839. void ToolUsed(short ToolNum, double X1, double Y1, double X2, double Y2, double Distance, BOOL Shift, BOOL Ctrl, BOOL* EnableDefault);
  840. void RequestData(LPCTSTR DataSetName, long Row, short Field, VARIANT* Value, BOOL* Done);
  841. void DataMismatch(LPCTSTR DataSetName, long Row, BSTR* GeoFieldValue);
  842. void MapViewChanged();
  843. void AnnotationAdded(LPDISPATCH Annotation);
  844. void AnnotationChanged(short ChangeType, LPDISPATCH Annotation, BOOL* EnableDefault);
  845. void ThemeModifyRequested(LPDISPATCH Theme);
  846. void DrawUserLayer(LPDISPATCH Layer, long hOutputDC, long hAttributeDC, LPDISPATCH RectFull, LPDISPATCH RectInvalid);
  847. void PolyToolUsed(short ToolNum, long Flags, LPDISPATCH Points, BOOL bShift, BOOL bCtrl, BOOL FAR* EnableDefault)
  848. void ResolveDataBindEx(short Flag, short NumMatches, const VARIANT& Matches, short* Choice, BOOL* Cancel);
  849. void MapDraw(short Flag);
  850. void AddFeatureToolUsed(short ToolNum, long Flags, IDispatch* Feature, boolean bShift, boolean bCtrl, boolean* EnableDefault);
  851. */
  852. /////////////////////////////////////////////////////////////////////////////
  853. // CMapXSourceRow wrapper class
  854. class CMapXSourceRow : public COleDispatchDriver
  855. {
  856. public:
  857. CMapXSourceRow() {} // Calls COleDispatchDriver default constructor
  858. CMapXSourceRow(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  859. CMapXSourceRow(const CMapXSourceRow& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  860. // Attributes
  861. public:
  862. long GetRow();
  863. // Operations
  864. public:
  865. };
  866. /////////////////////////////////////////////////////////////////////////////
  867. // CMapXSourceRows wrapper class
  868. class CMapXSourceRows : public COleDispatchDriver
  869. {
  870. public:
  871. CMapXSourceRows() {} // Calls COleDispatchDriver default constructor
  872. CMapXSourceRows(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  873. CMapXSourceRows(const CMapXSourceRows& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  874. CMapXSourceRow operator[](long Index) { return Item(Index); }
  875. // Attributes
  876. public:
  877. LPENUMVARIANT GetEnumerator();
  878. long GetCount();
  879. // Operations
  880. public:
  881. CMapXSourceRow Item(const VARIANT& Index);
  882. CMapXSourceRow Item(long Index) { return Item(COleVariant(Index)); }
  883. };
  884. /////////////////////////////////////////////////////////////////////////////
  885. // CMapXRowValue wrapper class
  886. class CMapXRowValue : public COleDispatchDriver
  887. {
  888. public:
  889. CMapXRowValue() {} // Calls COleDispatchDriver default constructor
  890. CMapXRowValue(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  891. CMapXRowValue(const CMapXRowValue& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  892. const CLSID& GetClsid() const
  893. {
  894. static bool bInitialized = false;
  895. static CLSID clsid;
  896. if(!bInitialized)
  897. {
  898. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".RowValue.") MAPX_VERSION);
  899. bInitialized = true;
  900. }
  901. return clsid;
  902. }
  903. // Attributes
  904. public:
  905. BOOL GetReadOnly();
  906. LPDISPATCH GetDataset();
  907. void SetDataset(LPDISPATCH);
  908. LPDISPATCH GetField();
  909. void SetField(LPDISPATCH);
  910. VARIANT GetValue();
  911. void SetValue(const VARIANT&);
  912. // Operations
  913. public:
  914. };
  915. /////////////////////////////////////////////////////////////////////////////
  916. // CMapXRowValues wrapper class
  917. class CMapXRowValues : public COleDispatchDriver
  918. {
  919. public:
  920. CMapXRowValues() {} // Calls COleDispatchDriver default constructor
  921. CMapXRowValues(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  922. CMapXRowValues(const CMapXRowValues& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  923. const CLSID& GetClsid() const
  924. {
  925. static bool bInitialized = false;
  926. static CLSID clsid;
  927. if(!bInitialized)
  928. {
  929. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".RowValues.") MAPX_VERSION);
  930. bInitialized = true;
  931. }
  932. return clsid;
  933. }
  934. // Attributes
  935. public:
  936. LPENUMVARIANT GetEnumerator();
  937. long GetCount();
  938. BOOL GetReadOnly();
  939. // Operations
  940. public:
  941. CMapXRowValue Item(const VARIANT& Index);
  942. CMapXRowValue Item(long Index) { return Item(COleVariant(Index)); }
  943. CMapXRowValue Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
  944. void Remove(const VARIANT& Index);
  945. CMapXRowValue Add(LPDISPATCH RowValue);
  946. void RemoveAll();
  947. CMapXRowValues Clone();
  948. };
  949. /////////////////////////////////////////////////////////////////////////////
  950. // CMapXDataset wrapper class
  951. class CMapXDataset : public COleDispatchDriver
  952. {
  953. public:
  954. CMapXDataset() {} // Calls COleDispatchDriver default constructor
  955. CMapXDataset(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  956. CMapXDataset(const CMapXDataset& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  957. // Attributes
  958. public:
  959. CString GetName();
  960. void SetName(LPCTSTR);
  961. long GetRowCount();
  962. CMapXFields GetFields();
  963. CMapXThemes GetThemes();
  964. long GetGeoField();
  965. long GetSecondaryGeoField();
  966. CMapXLayer GetLayer();
  967. short GetType();
  968. BOOL GetReadOnly();
  969. // Operations
  970. public:
  971. void Refresh();
  972. VARIANT GetValue(const VARIANT& Row, const VARIANT& Column);
  973. VARIANT GetValue(long Row, long Column)
  974. { return GetValue(COleVariant(Row), COleVariant(Column)); }
  975. VARIANT GetValue(long Row, LPCTSTR Column)
  976. { return GetValue(COleVariant(Row), COleVariant(Column)); }
  977. CMapXSourceRows GetSourceRows(const VARIANT& Row);
  978. CMapXSourceRows GetSourceRows(long Row)
  979. { return GetSourceRows(COleVariant(Row)); }
  980. CMapXRowValues GetRowValues(const VARIANT& Row);
  981. CMapXRowValues GetRowValues(long Row)
  982. { return GetRowValues(COleVariant(Row)); }
  983. CMapXField AddField(LPCTSTR Name, LPCTSTR Expression);
  984. };
  985. /////////////////////////////////////////////////////////////////////////////
  986. // CMapXDatasets wrapper class
  987. class CMapXDatasets : public COleDispatchDriver
  988. {
  989. public:
  990. CMapXDatasets() {} // Calls COleDispatchDriver default constructor
  991. CMapXDatasets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  992. CMapXDatasets(const CMapXDatasets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  993. // Attributes
  994. public:
  995. LPENUMVARIANT GetEnumerator();
  996. long GetCount();
  997. CMapXDataset operator[](long Index) { return Item(Index); }
  998. CMapXDataset operator[](LPCTSTR Index) { return Item(Index); }
  999. BOOL GetBuildSourceRows();
  1000. void SetBuildSourceRows(BOOL b);
  1001. // Operations
  1002. public:
  1003. CMapXDataset Add(long Type, const VARIANT& SourceData, const VARIANT& Name, const VARIANT& GeoField, const VARIANT& SecondaryGeoField, const VARIANT& BindLayer, const VARIANT& Fields, const VARIANT& Dynamic);
  1004. CMapXDataset Add(short Type, const VARIANT& SourceData, LPCTSTR Name=NULL, long GeoField=0)
  1005. { return Add( Type, SourceData, COleVariant(Name), COleVariant(GeoField),
  1006. COptionalVariant(), COptionalVariant(), COptionalVariant(), COptionalVariant());
  1007. }
  1008. CMapXDataset Item(const VARIANT& Index);
  1009. CMapXDataset Item(long Index) { return Item(COleVariant(Index)); }
  1010. CMapXDataset Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
  1011. void Remove(const VARIANT& Index);
  1012. void Remove(long Index) { Remove(COleVariant(Index)); }
  1013. void Remove(LPCTSTR Index) { Remove(COleVariant(Index)); }
  1014. CMapXDataset Restore(LPCTSTR Name, const VARIANT& SourceData);
  1015. void RemoveAll();
  1016. };
  1017. /////////////////////////////////////////////////////////////////////////////
  1018. // CMapXLabelProperties wrapper class
  1019. class CMapXLabelProperties : public COleDispatchDriver
  1020. {
  1021. public:
  1022. CMapXLabelProperties() {} // Calls COleDispatchDriver default constructor
  1023. CMapXLabelProperties(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1024. CMapXLabelProperties(const CMapXLabelProperties& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1025. // Attributes
  1026. public:
  1027. CMapXStyle GetStyle();
  1028. void SetStyle(LPDISPATCH);
  1029. BOOL GetVisible();
  1030. void SetVisible(BOOL);
  1031. BOOL GetLabelZoom();
  1032. void SetLabelZoom(BOOL);
  1033. double GetLabelZoomMin();
  1034. void SetLabelZoomMin(double);
  1035. double GetLabelZoomMax();
  1036. void SetLabelZoomMax(double);
  1037. short GetLineType();
  1038. void SetLineType(short);
  1039. short GetOffset();
  1040. void SetOffset(short);
  1041. BOOL GetParallel();
  1042. void SetParallel(BOOL);
  1043. CMapXDataset GetDataset();
  1044. void SetDataset(LPDISPATCH);
  1045. BOOL GetDuplicate();
  1046. void SetDuplicate(BOOL);
  1047. BOOL GetOverlap();
  1048. void SetOverlap(BOOL);
  1049. short GetLabelMax();
  1050. void SetLabelMax(short);
  1051. CMapXField GetDataField();
  1052. void SetDataField(LPDISPATCH);
  1053. short GetPosition();
  1054. void SetPosition(short);
  1055. BOOL GetPartialSegments();
  1056. void SetPartialSegments(BOOL);
  1057. BOOL GetLabelPartialObjects();
  1058. void SetLabelPartialObjects(BOOL);
  1059. // Operations
  1060. public:
  1061. };
  1062. /////////////////////////////////////////////////////////////////////////////
  1063. // CMapXFeature wrapper class
  1064. class CMapXFeature : public COleDispatchDriver
  1065. {
  1066. public:
  1067. CMapXFeature() {} // Calls COleDispatchDriver default constructor
  1068. CMapXFeature(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1069. CMapXFeature(const CMapXFeature& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1070. const CLSID& GetClsid() const
  1071. {
  1072. static bool bInitialized = false;
  1073. static CLSID clsid;
  1074. if(!bInitialized)
  1075. {
  1076. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Feature.") MAPX_VERSION);
  1077. bInitialized = true;
  1078. }
  1079. return clsid;
  1080. }
  1081. // Attributes
  1082. public:
  1083. long GetFeatureID();
  1084. short GetType();
  1085. void SetType(short);
  1086. double GetLength();
  1087. double GetCenterX();
  1088. double GetCenterY();
  1089. CMapXStyle GetStyle();
  1090. void SetStyle(LPDISPATCH);
  1091. CMapXRectangle GetBounds();
  1092. CMapXParts GetParts();
  1093. double GetArea();
  1094. CMapXLayer GetLayer();
  1095. CString GetCaption();
  1096. void SetCaption(LPCTSTR);
  1097. CMapXPoint GetPoint();
  1098. void SetPoint(LPDISPATCH);
  1099. CMapXPoint GetLabelPoint();
  1100. double GetPerimeter();
  1101. BOOL GetSmooth();
  1102. void SetSmooth(BOOL);
  1103. CString GetName();
  1104. CString GetKeyValue();
  1105. void SetKeyValue(LPCTSTR);
  1106. CString GetFeatureKey();
  1107. CMapXFeature GetRegion();
  1108. void SetRegion(LPDISPATCH);
  1109. CMapXFeature GetPolyline();
  1110. void SetPolyline(LPDISPATCH);
  1111. CMapXFeature GetMultipoint();
  1112. void SetMultipoint(LPDISPATCH);
  1113. BOOL GetHasRegion();
  1114. BOOL GetHasPolyline();
  1115. BOOL GetHasMultipoint();
  1116. // Operations
  1117. public:
  1118. void Update(const VARIANT& UpdateFeature, const VARIANT& RowValues);
  1119. void Update(bool UpdateFeature, LPDISPATCH RowValues)
  1120. { Update(COleVariant((short)UpdateFeature), COleVariantDispatch(RowValues)); }
  1121. void Update(bool UpdateFeature)
  1122. {
  1123. short sUpdateFeature = (short) UpdateFeature;
  1124. Update(COleVariant(sUpdateFeature), COptionalVariant());
  1125. }
  1126. void Update(LPDISPATCH RowValues)
  1127. {
  1128. Update(COptionalVariant(), COleVariantDispatch(RowValues));
  1129. }
  1130. void Update()
  1131. { Update(COptionalVariant(), COptionalVariant()); }
  1132. void Offset(double deltaX, double deltaY);
  1133. void Attach(LPDISPATCH Map);
  1134. CMapXFeature Clone();
  1135. VARIANT GetNodes(const VARIANT& CSys);
  1136. VARIANT GetNodes()
  1137. { return GetNodes(COptionalVariant()); }
  1138. void SetNodes(const VARIANT& CSys, const VARIANT& newValue);
  1139. // Obsolete. You should use GetNodes(CSys) instead:
  1140. VARIANT Nodes(const VARIANT& CSys);
  1141. // Obsolete. You should use GetNodes() instead:
  1142. VARIANT Nodes()
  1143. { return Nodes(COptionalVariant()); }
  1144. };
  1145. /////////////////////////////////////////////////////////////////////////////
  1146. // CMapXFeatures wrapper class
  1147. class CMapXFeatures : public COleDispatchDriver
  1148. {
  1149. public:
  1150. CMapXFeatures() {} // Calls COleDispatchDriver default constructor
  1151. CMapXFeatures(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1152. CMapXFeatures(const CMapXFeatures& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1153. CMapXFeature operator[](long Index) { return Item(Index); }
  1154. // Attributes
  1155. public:
  1156. LPENUMVARIANT GetEnumerator();
  1157. long GetCount();
  1158. CMapXRectangle GetBounds();
  1159. // Operations
  1160. public:
  1161. CMapXFeature Item(const VARIANT& Index);
  1162. CMapXFeature Item(long Index) { return Item(COleVariant(Index)); }
  1163. void Remove(const VARIANT& Source);
  1164. void Remove(long Index) { Remove(COleVariant(Index)); }
  1165. void Remove(LPDISPATCH Source=NULL)
  1166. { Remove(COleVariantDispatch(Source)); }
  1167. CMapXFeatures Clone();
  1168. void AddByID(const VARIANT& FeatureID);
  1169. void AddByID(long FeatureID)
  1170. { AddByID(COleVariant(FeatureID)); }
  1171. void AddByID(LPCTSTR FeatureID)
  1172. { AddByID(COleVariant(FeatureID)); }
  1173. void RemoveByID(const VARIANT& FeatureID);
  1174. void RemoveByID(long FeatureID)
  1175. { RemoveByID(COleVariant(FeatureID)); }
  1176. void RemoveByID(LPCTSTR FeatureID)
  1177. { RemoveByID(COleVariant(FeatureID)); }
  1178. void Add(LPDISPATCH Source);
  1179. void Common(LPDISPATCH Source);
  1180. void Replace(LPDISPATCH Source);
  1181. };
  1182. /////////////////////////////////////////////////////////////////////////////
  1183. // CMapXLayer wrapper class
  1184. class CMapXLayer : public COleDispatchDriver
  1185. {
  1186. public:
  1187. CMapXLayer() {} // Calls COleDispatchDriver default constructor
  1188. CMapXLayer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1189. CMapXLayer(const CMapXLayer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1190. // Attributes
  1191. public:
  1192. CString GetName();
  1193. void SetName(LPCTSTR);
  1194. BOOL GetVisible();
  1195. void SetVisible(BOOL);
  1196. BOOL GetSelectable();
  1197. void SetSelectable(BOOL);
  1198. CString GetFilespec();
  1199. CMapXLabelProperties GetLabelProperties();
  1200. CMapXLabelProperties GetLabel() { return GetLabelProperties(); }
  1201. BOOL GetAutoLabel();
  1202. void SetAutoLabel(BOOL);
  1203. BOOL GetZoomLayer();
  1204. void SetZoomLayer(BOOL);
  1205. BOOL GetOverrideStyle();
  1206. void SetOverrideStyle(BOOL);
  1207. CMapXStyle GetStyle();
  1208. void SetStyle(LPDISPATCH);
  1209. double GetZoomMin();
  1210. void SetZoomMin(double);
  1211. double GetZoomMax();
  1212. void SetZoomMax(double);
  1213. CMapXSelection GetSelection();
  1214. short GetPredominantFeatureType();
  1215. CMapXLayerFind GetFind();
  1216. short GetType();
  1217. CString GetKeyField();
  1218. void SetKeyField(LPCTSTR);
  1219. CMapXCoordSys GetCoordSys();
  1220. CMapXRectangle GetBounds();
  1221. BOOL GetDrawLabelsAfter();
  1222. void SetDrawLabelsAfter(BOOL);
  1223. CMapXDatasets GetDatasets();
  1224. BOOL GetShowNodes();
  1225. void SetShowNodes(BOOL propVal);
  1226. BOOL GetShowCentroids();
  1227. void SetShowCentroids(BOOL propVal);
  1228. BOOL GetShowLineDirection();
  1229. void SetShowLineDirection(BOOL propVal);
  1230. BOOL GetEditable();
  1231. void SetEditable(BOOL propVal);
  1232. CMapXRectangle GetClippedBounds();
  1233. // Operations
  1234. public:
  1235. void LabelAtPoint(double X, double Y);
  1236. void ClearCustomLabels();
  1237. CMapXFeature AddFeature(LPDISPATCH Source, const VARIANT& RowValues);
  1238. CMapXFeature AddFeature(LPDISPATCH Source)
  1239. { return AddFeature(Source, COptionalVariant()); }
  1240. CMapXFeature AddFeature(LPDISPATCH Source, LPDISPATCH RowValues)
  1241. {
  1242. return AddFeature(Source, COleVariantDispatch(RowValues));
  1243. }
  1244. void UpdateFeature(const VARIANT& Target, const VARIANT& Source, const VARIANT& RowValues);
  1245. void UpdateFeature(LPDISPATCH Target, LPDISPATCH Source, LPDISPATCH RowValues)
  1246. {
  1247. UpdateFeature(COleVariantDispatch(Target), COleVariantDispatch(Source), COleVariantDispatch(RowValues));
  1248. }
  1249. void UpdateFeature(LPCTSTR Target, LPDISPATCH Source, LPDISPATCH RowValues)
  1250. {
  1251. UpdateFeature(COleVariant(Target), COleVariantDispatch(Source), COleVariantDispatch(RowValues));
  1252. }
  1253. void UpdateFeature(long Target, LPDISPATCH Source, LPDISPATCH RowValues)
  1254. {
  1255. UpdateFeature(COleVariant(Target), COleVariantDispatch(Source), COleVariantDispatch(RowValues));
  1256. }
  1257. void UpdateFeature(LPDISPATCH Target, LPDISPATCH Source)
  1258. {
  1259. UpdateFeature(COleVariantDispatch(Target), COleVariantDispatch(Source), COptionalVariant());
  1260. }
  1261. void UpdateFeature(LPCTSTR Target, LPDISPATCH Source)
  1262. {
  1263. UpdateFeature(COleVariant(Target), COleVariantDispatch(Source), COptionalVariant());
  1264. }
  1265. void UpdateFeature(long Target, LPDISPATCH Source)
  1266. {
  1267. UpdateFeature(COleVariant(Target), COleVariantDispatch(Source), COptionalVariant());
  1268. }
  1269. void UpdateFeature(LPDISPATCH Target)
  1270. {
  1271. UpdateFeature(COleVariantDispatch(Target), COptionalVariant(), COptionalVariant());
  1272. }
  1273. void UpdateFeature(LPCTSTR Target)
  1274. { UpdateFeature(COleVariant(Target), COptionalVariant(), COptionalVariant()); }
  1275. void UpdateFeature(long Target)
  1276. { UpdateFeature(COleVariant(Target), COptionalVariant(), COptionalVariant()); }
  1277. void DeleteFeature(const VARIANT& Target);
  1278. void DeleteFeature(LPDISPATCH Target)
  1279. {
  1280. DeleteFeature(COleVariantDispatch(Target));
  1281. }
  1282. void DeleteFeature(LPCTSTR Target)
  1283. { DeleteFeature(COleVariant(Target)); }
  1284. void DeleteFeature(long Target)
  1285. { DeleteFeature(COleVariant(Target)); }
  1286. void Invalidate(const VARIANT& InvalidRect);
  1287. void Invalidate() { Invalidate(COptionalVariant()); }
  1288. CMapXFeatures SearchWithinDistance(LPDISPATCH Source, double Distance, short Units, short SearchType);
  1289. CMapXFeatures SearchWithinRectangle(LPDISPATCH Rectangle, short SearchType);
  1290. CMapXFeatures AllFeatures();
  1291. CMapXFeatures NoFeatures();
  1292. CMapXFeatures SearchWithinFeature(LPDISPATCH Feature, short SearchType);
  1293. CMapXFeatures SearchAtPoint(LPDISPATCH Point, short SearchResultFlags = miSearchResultAll);
  1294. void DrillDownRemoveFeatures(LPCTSTR Level, const VARIANT& FeatureKeys);
  1295. void DrillDownAddFeatures(LPCTSTR Level, const VARIANT& FeatureKeys);
  1296. CMapXFeatures GetDrilldownFeaturesByID(LPCTSTR Level, const VARIANT& FeatureKeys);
  1297. void DrilldownReset(LPCTSTR Level);
  1298. CMapXFeature GetFeatureByID(long FeatureID);
  1299. void Refresh();
  1300. long FeatureIDFromFeatureName(LPCTSTR Name);
  1301. CMapXFeatures Search(LPCTSTR Where, const VARIANT& Variables);
  1302. CMapXFeatures Search(LPCTSTR Where)
  1303. { return Search(Where, COptionalVariant()); }
  1304. CMapXFeatures Search(LPCTSTR Where, LPDISPATCH Variables)
  1305. { return Search(Where, COleVariantDispatch(Variables)); }
  1306. void BeginAccess(long BeginAccessType);
  1307. void EndAccess(const VARIANT& EndAccessType);
  1308. void EndAccess()
  1309. { EndAccess(COptionalVariant()); }
  1310. CMapXFeature GetFeatureByKey(LPCTSTR);
  1311. CString FeatureKeyFromFeatureName(LPCTSTR);
  1312. };
  1313. class CMapXLayers : public COleDispatchDriver
  1314. {
  1315. public:
  1316. CMapXLayers() {} // Calls COleDispatchDriver default constructor
  1317. CMapXLayers(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1318. CMapXLayers(const CMapXLayers& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1319. CMapXLayer operator[](long Index) { return Item(Index); }
  1320. CMapXLayer operator[](LPCTSTR Index) { return Item(Index); }
  1321. // Attributes
  1322. public:
  1323. LPENUMVARIANT GetEnumerator();
  1324. long GetCount();
  1325. CMapXLayer GetAnimationLayer();
  1326. void SetAnimationLayer(LPDISPATCH);
  1327. CMapXRectangle GetBounds();
  1328. CMapXLayer GetInsertionLayer();
  1329. void SetInsertionLayer(LPDISPATCH);
  1330. CMapXRectangle GetClippedBounds();
  1331. // Operations
  1332. public:
  1333. void ClearSelection();
  1334. BOOL Move(short From, short To);
  1335. CMapXLayer Add(const VARIANT& LayerInfo, const VARIANT& Position);
  1336. CMapXLayer Add(LPDISPATCH LayerInfo)
  1337. {
  1338. return Add(COleVariantDispatch(LayerInfo), COptionalVariant());
  1339. }
  1340. CMapXLayer Add(LPDISPATCH LayerInfo, long Position)
  1341. {
  1342. return Add(COleVariantDispatch(LayerInfo), COleVariant(Position));
  1343. }
  1344. CMapXLayer Add(LPCTSTR Filespec, const VARIANT& Position)
  1345. { return Add(COleVariant(Filespec), Position); }
  1346. CMapXLayer Add(LPCTSTR Filespec) // for backward compatiblity
  1347. { return Add(COleVariant(Filespec), COptionalVariant()); }
  1348. CMapXLayer Add(LPCTSTR Filespec, long Position)
  1349. { return Add(COleVariant(Filespec), COleVariant(Position)); }
  1350. void AddGeoSetLayers(LPCTSTR GeoSetName);
  1351. CMapXLayer Item(const VARIANT& Index);
  1352. CMapXLayer Item(long Index) { return Item(COleVariant(Index)); }
  1353. CMapXLayer Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
  1354. void Remove(const VARIANT& Index);
  1355. void Remove(long Index) { Remove(COleVariant(Index)); }
  1356. void Remove(LPCTSTR Index) { Remove(COleVariant(Index)); }
  1357. CMapXLayer AddUserDrawLayer(LPCTSTR Name, short Position);
  1358. CMapXLayer CreateLayer(LPCTSTR Name, const VARIANT& Filespec, const VARIANT& Position, const VARIANT& KeyLength, const VARIANT& CoordSys);
  1359. CMapXLayer CreateLayer(LPCTSTR Name, LPCTSTR Filespec=NULL, long Position=-1, short KeyLength=32)
  1360. { return CreateLayer(Name, COleVariant(Filespec), COleVariant(Position), COleVariant(KeyLength), COptionalVariant()); }
  1361. BOOL LayersDlg(const VARIANT& HelpFile, const VARIANT& HelpID);
  1362. BOOL LayersDlg(LPCTSTR HelpFile, UINT HelpID=HELP_FINDER)
  1363. { return LayersDlg(COleVariant(HelpFile), COleVariant((long)HelpID)); }
  1364. BOOL LayersDlg()
  1365. { return LayersDlg(COptionalVariant(), COptionalVariant()); }
  1366. CMapXLayer AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query, const VARIANT& Position, const VARIANT& Options);
  1367. CMapXLayer AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query, long Position, long Options=0)
  1368. { return AddServerLayer(Name, ConnectString, Query, COleVariant(Position), COleVariant(Options)); }
  1369. CMapXLayer AddServerLayer(LPCTSTR Name, LPCTSTR ConnectString, LPCTSTR Query)
  1370. { return AddServerLayer(Name, ConnectString, Query, COptionalVariant(), COptionalVariant()); }
  1371. void RemoveAll();
  1372. };
  1373. /////////////////////////////////////////////////////////////////////////////
  1374. // CMapXField wrapper class
  1375. class CMapXField : public COleDispatchDriver
  1376. {
  1377. public:
  1378. CMapXField() {} // Calls COleDispatchDriver default constructor
  1379. CMapXField(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1380. CMapXField(const CMapXField& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1381. // Attributes
  1382. public:
  1383. long GetType();
  1384. CString GetName();
  1385. long GetAggregationFunction();
  1386. short GetWidth();
  1387. short GetPrecision();
  1388. short GetDecimals();
  1389. BOOL GetIndexed();
  1390. long GetTypeEx();
  1391. // Operations
  1392. public:
  1393. };
  1394. /////////////////////////////////////////////////////////////////////////////
  1395. // CMapXTheme wrapper class
  1396. class CMapXTheme : public COleDispatchDriver
  1397. {
  1398. public:
  1399. CMapXTheme() {} // Calls COleDispatchDriver default constructor
  1400. CMapXTheme(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1401. CMapXTheme(const CMapXTheme& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1402. // Attributes
  1403. public:
  1404. BOOL GetVisible();
  1405. void SetVisible(BOOL);
  1406. short GetType();
  1407. CMapXThemeProperties GetProperties();
  1408. CMapXLegend GetLegend();
  1409. BOOL GetAutoRecompute();
  1410. void SetAutoRecompute(BOOL);
  1411. CString GetName();
  1412. void SetName(LPCTSTR);
  1413. CMapXThemeProperties GetThemeProperties();
  1414. CMapXLayer GetLayer();
  1415. CMapXFields GetFields();
  1416. double GetDataMin();
  1417. void SetDataMin(double);
  1418. double GetDataMax();
  1419. void SetDataMax(double);
  1420. BOOL GetComputeTheme();
  1421. void SetComputeTheme(BOOL);
  1422. long GetThemedFeatureType();
  1423. // Operations
  1424. public:
  1425. BOOL ThemeDlg(const VARIANT& HelpFile, const VARIANT& HelpID);
  1426. BOOL ThemeDlg(LPCTSTR HelpFile, UINT HelpID=HELP_FINDER)
  1427. { return ThemeDlg(COleVariant(HelpFile), COleVariant((long)HelpID)); }
  1428. BOOL ThemeDlg()
  1429. { return ThemeDlg(COptionalVariant(), COptionalVariant()); }
  1430. };
  1431. /////////////////////////////////////////////////////////////////////////////
  1432. // CMapXThemes wrapper class
  1433. class CMapXThemes : public COleDispatchDriver
  1434. {
  1435. public:
  1436. CMapXThemes() {} // Calls COleDispatchDriver default constructor
  1437. CMapXThemes(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1438. CMapXThemes(const CMapXThemes& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1439. CMapXTheme operator[](long Index) { return Item(Index); }
  1440. CMapXTheme operator[](LPCTSTR Index) { return Item(Index); }
  1441. // Attributes
  1442. public:
  1443. LPENUMVARIANT GetEnumerator();
  1444. long GetCount();
  1445. // Operations
  1446. public:
  1447. CMapXTheme Add(const VARIANT& Type, const VARIANT& Field, const VARIANT& Name, const VARIANT& ComputeTheme);
  1448. CMapXTheme Add(const VARIANT& Type, const VARIANT& Field, const VARIANT& Name)
  1449. { return Add(COleVariant(Type), COleVariant(Field), COleVariant(Name), COptionalVariant()); }
  1450. CMapXTheme Add(short Type, long Field, LPCTSTR Name)
  1451. { return Add(COleVariant(Type), COleVariant(Field), COleVariant(Name), COptionalVariant()); }
  1452. CMapXTheme Add(short Type, LPCTSTR Field, LPCTSTR Name)
  1453. { return Add(COleVariant(Type), COleVariant(Field), COleVariant(Name), COptionalVariant()); }
  1454. CMapXTheme Add(short Type, long Field)
  1455. { return Add(COleVariant(Type), COleVariant(Field), COptionalVariant(), COptionalVariant()); }
  1456. CMapXTheme Add(short Type, LPCTSTR Field)
  1457. { return Add(COleVariant(Type), COleVariant(Field), COptionalVariant(), COptionalVariant()); }
  1458. CMapXTheme Add(short Type=miThemeAuto)
  1459. { return Add(COleVariant(Type), COptionalVariant(), COptionalVariant(), COptionalVariant()); }
  1460. CMapXTheme Item(const VARIANT& Index);
  1461. CMapXTheme Item(long Index) { return Item(COleVariant(Index)); }
  1462. CMapXTheme Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
  1463. void Remove(const VARIANT& Index);
  1464. void Remove(long Index) { Remove(COleVariant(Index)); }
  1465. void Remove(LPCTSTR Index) { Remove(COleVariant(Index)); }
  1466. void RemoveAll();
  1467. };
  1468. /////////////////////////////////////////////////////////////////////////////
  1469. // CMapXLegend wrapper class
  1470. class CMapXLegend : public COleDispatchDriver
  1471. {
  1472. public:
  1473. CMapXLegend() {} // Calls COleDispatchDriver default constructor
  1474. CMapXLegend(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1475. CMapXLegend(const CMapXLegend& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1476. // Attributes
  1477. public:
  1478. BOOL GetCompact();
  1479. void SetCompact(BOOL);
  1480. BOOL GetVisible();
  1481. void SetVisible(BOOL);
  1482. CMapXStyle GetTitleStyle();
  1483. void SetTitleStyle(LPDISPATCH);
  1484. CMapXStyle GetSubTitleStyle();
  1485. void SetSubTitleStyle(LPDISPATCH);
  1486. CMapXStyle GetCompactTitleStyle();
  1487. void SetCompactTitleStyle(LPDISPATCH);
  1488. CMapXStyle GetBodyTextStyle();
  1489. void SetBodyTextStyle(LPDISPATCH);
  1490. CMapXLegendTexts GetLegendTexts();
  1491. BOOL GetCurrencyFormat();
  1492. void SetCurrencyFormat(BOOL);
  1493. CString GetTitle();
  1494. void SetTitle(LPCTSTR);
  1495. CString GetSubTitle();
  1496. void SetSubTitle(LPCTSTR);
  1497. CString GetCompactTitle();
  1498. void SetCompactTitle(LPCTSTR);
  1499. double GetLeft();
  1500. void SetLeft(double);
  1501. double GetTop();
  1502. void SetTop(double);
  1503. double GetWidth();
  1504. double GetHeight();
  1505. BOOL GetShowEmptyRanges();
  1506. void SetShowEmptyRanges(BOOL);
  1507. BOOL GetShowCount();
  1508. void SetShowCount(BOOL propVal);
  1509. double GetPaperHeight();
  1510. double GetPaperWidth();
  1511. // Operations
  1512. public:
  1513. BOOL LegendDlg(const VARIANT& HelpFile, const VARIANT& HelpID);
  1514. BOOL LegendDlg(LPCTSTR HelpFile, UINT HelpID=HELP_FINDER)
  1515. { return LegendDlg(COleVariant(HelpFile), COleVariant((long)HelpID)); }
  1516. BOOL LegendDlg()
  1517. { return LegendDlg(COptionalVariant(), COptionalVariant()); }
  1518. void ExportLegend(LPCTSTR Destination, short Format);
  1519. void PrintLegend(long hDC, long X, long Y, long W, long H);
  1520. };
  1521. /////////////////////////////////////////////////////////////////////////////
  1522. // CMapXAnnotation wrapper class
  1523. class CMapXAnnotation : public COleDispatchDriver
  1524. {
  1525. public:
  1526. CMapXAnnotation() {} // Calls COleDispatchDriver default constructor
  1527. CMapXAnnotation(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1528. CMapXAnnotation(const CMapXAnnotation& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1529. // Attributes
  1530. public:
  1531. short GetType();
  1532. CMapXGraphic GetGraphic();
  1533. // Operations
  1534. public:
  1535. };
  1536. /////////////////////////////////////////////////////////////////////////////
  1537. // CMapXAnnotations wrapper class
  1538. class CMapXAnnotations : public COleDispatchDriver
  1539. {
  1540. public:
  1541. CMapXAnnotations() {} // Calls COleDispatchDriver default constructor
  1542. CMapXAnnotations(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1543. CMapXAnnotations(const CMapXAnnotations& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1544. CMapXAnnotation operator[](long Index) { return Item(Index); }
  1545. CMapXAnnotation operator[](LPCTSTR Index) { return Item(Index); }
  1546. // Attributes
  1547. public:
  1548. LPENUMVARIANT GetEnumerator();
  1549. BOOL GetEditable();
  1550. void SetEditable(BOOL);
  1551. long GetCount();
  1552. // Operations
  1553. public:
  1554. CMapXAnnotation Item(const VARIANT& Index);
  1555. CMapXAnnotation Item(long Index) { return Item(COleVariant(Index)); }
  1556. CMapXAnnotation Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
  1557. void Remove(const VARIANT& Index);
  1558. void Remove(long Index) { Remove(COleVariant(Index)); }
  1559. CMapXAnnotation AddSymbol(double X, double Y);
  1560. CMapXAnnotation AddText(LPCTSTR Text, double X, double Y, const VARIANT& Position);
  1561. CMapXAnnotation AddText(LPCTSTR Text, double X, double Y, short Position)
  1562. { return AddText(Text, X, Y, COleVariant(Position)); }
  1563. void RemoveAll();
  1564. CMapXAnnotation ActiveAnnotation();
  1565. };
  1566. /////////////////////////////////////////////////////////////////////////////
  1567. // CMapXThemeProps wrapper class
  1568. class CMapXThemeProperties : public COleDispatchDriver
  1569. {
  1570. public:
  1571. CMapXThemeProperties() {} // Calls COleDispatchDriver default constructor
  1572. CMapXThemeProperties(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1573. CMapXThemeProperties(const CMapXThemeProperties& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1574. // Attributes
  1575. public:
  1576. short GetDistMethod();
  1577. void SetDistMethod(short);
  1578. short GetNumRanges();
  1579. void SetNumRanges(short);
  1580. CMapXRangeCategories GetRangeCategories();
  1581. short GetDotSize();
  1582. void SetDotSize(short);
  1583. BOOL GetGraduated();
  1584. void SetGraduated(BOOL);
  1585. CMapXMultivarCategories GetMultivarCategories();
  1586. BOOL GetIndependent();
  1587. void SetIndependent(BOOL);
  1588. CMapXIndividualValueCategories GetIndividualValueCategories();
  1589. double GetValuePerDot();
  1590. void SetValuePerDot(double);
  1591. double GetDataValue();
  1592. void SetDataValue(double);
  1593. double GetSize();
  1594. void SetSize(double);
  1595. double GetWidth();
  1596. void SetWidth(double);
  1597. CMapXStyle GetSymbolStyle();
  1598. void SetSymbolStyle(LPDISPATCH);
  1599. short GetSpreadBy();
  1600. void SetSpreadBy(short);
  1601. BOOL GetAllowEmptyRanges();
  1602. void SetAllowEmptyRanges(BOOL);
  1603. unsigned long GetDotColor();
  1604. void SetDotColor(unsigned long);
  1605. BOOL GetPieClockwise();
  1606. void SetPieClockwise(BOOL);
  1607. BOOL GetPieHalfPies();
  1608. void SetPieHalfPies(BOOL);
  1609. short GetPieStartAngle();
  1610. void SetPieStartAngle(short);
  1611. BOOL GetBarStacked();
  1612. void SetBarStacked(BOOL);
  1613. CMapXStyle GetNegativeSymbolStyle();
  1614. void SetNegativeSymbolStyle(LPDISPATCH);
  1615. BOOL GetShowNegativeValues();
  1616. void SetShowNegativeValues(BOOL);
  1617. short GetGraduateSizeBy();
  1618. void SetGraduateSizeBy(short);
  1619. CMapXStyle GetBorderStyle();
  1620. void SetBorderStyle(LPDISPATCH);
  1621. double GetBarWidth();
  1622. void SetBarWidth(double);
  1623. BOOL GetBarIndependentScale();
  1624. void SetBarIndependentScale(BOOL);
  1625. CMapXStyle GetPositiveSymbolStyle();
  1626. void SetPositiveSymbolStyle(LPDISPATCH);
  1627. CMapXStyle GetBarFrameStyle();
  1628. void SetBarFrameStyle(LPDISPATCH);
  1629. BOOL GetPieGraduated();
  1630. void SetPieGraduated(BOOL);
  1631. BOOL GetBarGraduatedStack();
  1632. void SetBarGraduatedStack(BOOL);
  1633. short GetApplyAttribute();
  1634. void SetApplyAttribute(short);
  1635. BOOL GetRoundRanges();
  1636. void SetRoundRanges(BOOL);
  1637. double GetRoundBy();
  1638. void SetRoundBy(double);
  1639. short GetColorMethod();
  1640. void SetColorMethod(short);
  1641. BOOL GetInflectRanges();
  1642. void SetInflectRanges(BOOL);
  1643. short GetInflectionRange();
  1644. void SetInflectionRange(short);
  1645. unsigned long GetInflectionColor();
  1646. void SetInflectionColor(unsigned long);
  1647. BOOL GetBarFramed();
  1648. void SetBarFramed(BOOL);
  1649. // Operations
  1650. public:
  1651. };
  1652. /////////////////////////////////////////////////////////////////////////////
  1653. // CMapXSelection wrapper class
  1654. class CMapXSelection : public COleDispatchDriver
  1655. {
  1656. public:
  1657. CMapXSelection() {} // Calls COleDispatchDriver default constructor
  1658. CMapXSelection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1659. CMapXSelection(const CMapXSelection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1660. CMapXFeature operator[](long Index) { return Item(Index); }
  1661. // Attributes
  1662. public:
  1663. LPENUMVARIANT GetEnumerator();
  1664. long GetCount();
  1665. CMapXRectangle GetBounds();
  1666. // Operations
  1667. public:
  1668. void SelectByRegion(LPDISPATCH Layer, const VARIANT& FeatureID, short Flag);
  1669. void SelectByRegion(LPDISPATCH Layer, long FeatureID, short Flag)
  1670. { SelectByRegion(Layer, COleVariant(FeatureID), Flag); }
  1671. void SelectByRegion(LPDISPATCH Layer, LPCTSTR FeatureID, short Flag)
  1672. { SelectByRegion(Layer, COleVariant(FeatureID), Flag); }
  1673. void ClearSelection();
  1674. void SelectByPoint(double X, double Y, short SelectFlag, short SearchResultFlags = miSearchResultAll);
  1675. void SelectByRadius(double X, double Y, double radius, short Flag);
  1676. void SelectByRectangle(double X1, double Y1, double X2, double Y2, short Flag);
  1677. BOOL SelectAll(short Flag);
  1678. void SelectByID(const VARIANT& FeatureID, short Flag);
  1679. void SelectByID(long FeatureID, short Flag)
  1680. { SelectByID(COleVariant(FeatureID), Flag); }
  1681. void SelectByID(LPCTSTR FeatureID, short Flag)
  1682. { SelectByID(COleVariant(FeatureID), Flag); }
  1683. CMapXFeature Item(const VARIANT& Index);
  1684. CMapXFeature Item(long Index) { return Item(COleVariant(Index)); }
  1685. void Remove(const VARIANT& Source);
  1686. void Remove(long Index) { Remove(COleVariant(Index)); }
  1687. void Remove(LPDISPATCH Source=NULL)
  1688. { Remove(COleVariantDispatch(Source));}
  1689. CMapXFeatures Clone();
  1690. void Add(LPDISPATCH Source);
  1691. void Common(LPDISPATCH Source);
  1692. void Replace(LPDISPATCH Source);
  1693. void AddByID(const VARIANT& FeatureID);
  1694. void RemoveByID(const VARIANT& FeatureID);
  1695. };
  1696. /////////////////////////////////////////////////////////////////////////////
  1697. // CMapXRangeCategory wrapper class
  1698. class CMapXRangeCategory : public COleDispatchDriver
  1699. {
  1700. public:
  1701. CMapXRangeCategory() {} // Calls COleDispatchDriver default constructor
  1702. CMapXRangeCategory(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1703. CMapXRangeCategory(const CMapXRangeCategory& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1704. // Attributes
  1705. public:
  1706. double GetMin();
  1707. void SetMin(double);
  1708. double GetMax();
  1709. void SetMax(double);
  1710. long GetNumItems();
  1711. CMapXStyle GetStyle();
  1712. void SetStyle(LPDISPATCH);
  1713. // Operations
  1714. public:
  1715. };
  1716. /////////////////////////////////////////////////////////////////////////////
  1717. // CMapXFields wrapper class
  1718. class CMapXFields : public COleDispatchDriver
  1719. {
  1720. public:
  1721. CMapXFields() {} // Calls COleDispatchDriver default constructor
  1722. CMapXFields(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1723. CMapXFields(const CMapXFields& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1724. const CLSID& GetClsid() const
  1725. {
  1726. static bool bInitialized = false;
  1727. static CLSID clsid;
  1728. if(!bInitialized)
  1729. {
  1730. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Fields.") MAPX_VERSION);
  1731. bInitialized = true;
  1732. }
  1733. return clsid;
  1734. }
  1735. CMapXField operator[](long Index) { return Item(Index); }
  1736. CMapXField operator[](LPCTSTR Index) { return Item(Index); }
  1737. // Attributes
  1738. public:
  1739. LPENUMVARIANT GetEnumerator();
  1740. long GetCount();
  1741. // Operations
  1742. public:
  1743. CMapXField Add(const VARIANT& SourceField, const VARIANT& Name, const VARIANT& AggregationFunction, const VARIANT& Type);
  1744. CMapXField Add(LPCTSTR SourceField, LPCTSTR Name=_T(""), short AggregationFunction=miAggregationAuto)
  1745. { return Add(COleVariant(SourceField), COleVariant(Name), COleVariant(AggregationFunction), COptionalVariant()); }
  1746. CMapXField Add(long SourceField, LPCTSTR Name=_T(""), short AggregationFunction=miAggregationAuto)
  1747. { return Add(COleVariant(SourceField), COleVariant(Name), COleVariant(AggregationFunction), COptionalVariant()); }
  1748. CMapXField Item(const VARIANT& Index);
  1749. CMapXField Item(long Index) { return Item(COleVariant(Index)); }
  1750. CMapXField Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
  1751. void Remove(const VARIANT& Index);
  1752. void Remove(long Index) { Remove(COleVariant(Index)); }
  1753. void Remove(LPCTSTR Index) { Remove(COleVariant(Index)); }
  1754. void RemoveAll();
  1755. CMapXField AddStringField(const VARIANT& Name, const VARIANT& Width, const VARIANT& Indexed);
  1756. CMapXField AddStringField(const VARIANT& Name, const VARIANT& Width)
  1757. {
  1758. return AddStringField(Name, Width, COptionalVariant());
  1759. }
  1760. CMapXField AddStringField(LPCTSTR Name, long Width, BOOL Indexed = FALSE)
  1761. {
  1762. short sIndexed = (short) Indexed;
  1763. return AddStringField(COleVariant(Name), COleVariant(Width), COleVariant(sIndexed));
  1764. }
  1765. CMapXField AddLogicalField(const VARIANT& Name, const VARIANT& Indexed);
  1766. CMapXField AddLogicalField(const VARIANT& Name)
  1767. {
  1768. return AddLogicalField(Name, COptionalVariant());
  1769. }
  1770. CMapXField AddLogicalField(LPCTSTR Name, BOOL Indexed = FALSE)
  1771. {
  1772. short sIndexed = (short) Indexed;
  1773. return AddLogicalField(COleVariant(Name), COleVariant(sIndexed));
  1774. }
  1775. CMapXField AddIntegerField(const VARIANT& Name, const VARIANT& Indexed);
  1776. CMapXField AddIntegerField(const VARIANT& Name)
  1777. {
  1778. return AddIntegerField(Name, COptionalVariant());
  1779. }
  1780. CMapXField AddIntegerField(LPCTSTR Name, BOOL Indexed = FALSE)
  1781. {
  1782. short sIndexed = (short) Indexed;
  1783. return AddIntegerField(COleVariant(Name), COleVariant(sIndexed));
  1784. }
  1785. CMapXField AddSmallIntField(const VARIANT& Name, const VARIANT& Indexed);
  1786. CMapXField AddSmallIntField(const VARIANT& Name)
  1787. {
  1788. return AddSmallIntField(Name, COptionalVariant());
  1789. }
  1790. CMapXField AddSmallIntField(LPCTSTR Name, BOOL Indexed = FALSE)
  1791. {
  1792. short sIndexed = (short) Indexed;
  1793. return AddSmallIntField(COleVariant(Name), COleVariant(sIndexed));
  1794. }
  1795. CMapXField AddNumericField(const VARIANT& Name, const VARIANT& Precision, const VARIANT& Decimals, const VARIANT& Indexed);
  1796. CMapXField AddNumericField(const VARIANT& Name, const VARIANT& Precision, const VARIANT& Decimals)
  1797. {
  1798. return AddNumericField(Name, Precision, Decimals, COptionalVariant());
  1799. }
  1800. CMapXField AddNumericField(LPCTSTR Name, long Precision, long Decimals, BOOL Indexed = FALSE)
  1801. {
  1802. short sIndexed = (short) Indexed;
  1803. return AddNumericField(COleVariant(Name), COleVariant(Precision), COleVariant(Decimals), COleVariant(sIndexed));
  1804. }
  1805. CMapXField AddFloatField(const VARIANT& Name, const VARIANT& Indexed);
  1806. CMapXField AddFloatField(const VARIANT& Name)
  1807. {
  1808. return AddFloatField(Name, COptionalVariant());
  1809. }
  1810. CMapXField AddFloatField(LPCTSTR Name, BOOL Indexed = FALSE)
  1811. {
  1812. short sIndexed = (short) Indexed;
  1813. return AddFloatField(COleVariant(Name), COleVariant(sIndexed));
  1814. }
  1815. CMapXField AddDateField(const VARIANT& Name, const VARIANT& Indexed);
  1816. CMapXField AddDateField(const VARIANT& Name)
  1817. {
  1818. return AddDateField(Name, COptionalVariant());
  1819. }
  1820. CMapXField AddDateField(LPCTSTR Name, BOOL Indexed = FALSE)
  1821. {
  1822. short sIndexed = (short) Indexed;
  1823. return AddDateField(COleVariant(Name), COleVariant(sIndexed));
  1824. }
  1825. };
  1826. class COleFont : public COleDispatchDriver
  1827. {
  1828. public:
  1829. COleFont() {} // Calls COleDispatchDriver default constructor
  1830. COleFont(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1831. COleFont(const COleFont& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1832. // Attributes
  1833. public:
  1834. CString GetName();
  1835. void SetName(LPCTSTR);
  1836. CY GetSize();
  1837. void SetSize(const CY&);
  1838. BOOL GetBold();
  1839. void SetBold(BOOL);
  1840. BOOL GetItalic();
  1841. void SetItalic(BOOL);
  1842. BOOL GetUnderline();
  1843. void SetUnderline(BOOL);
  1844. BOOL GetStrikethrough();
  1845. void SetStrikethrough(BOOL);
  1846. short GetWeight();
  1847. void SetWeight(short);
  1848. short GetCharset();
  1849. void SetCharset(short);
  1850. // Operations
  1851. public:
  1852. };
  1853. /////////////////////////////////////////////////////////////////////////////
  1854. // CMapXStyle wrapper class
  1855. class CMapXStyle : public COleDispatchDriver
  1856. {
  1857. public:
  1858. CMapXStyle() {} // Calls COleDispatchDriver default constructor
  1859. CMapXStyle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1860. CMapXStyle(const CMapXStyle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1861. const CLSID& GetClsid() const
  1862. {
  1863. static bool bInitialized = false;
  1864. static CLSID clsid;
  1865. if(!bInitialized)
  1866. {
  1867. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Style.") MAPX_VERSION);
  1868. bInitialized = true;
  1869. }
  1870. return clsid;
  1871. }
  1872. // Attributes
  1873. public:
  1874. short GetSymbolCharacter();
  1875. void SetSymbolCharacter(short);
  1876. unsigned long GetLineColor();
  1877. void SetLineColor(unsigned long);
  1878. short GetLineStyle();
  1879. void SetLineStyle(short);
  1880. short GetLineWidth();
  1881. void SetLineWidth(short);
  1882. unsigned long GetRegionColor();
  1883. void SetRegionColor(unsigned long);
  1884. short GetRegionPattern();
  1885. void SetRegionPattern(short);
  1886. BOOL GetRegionTransparent();
  1887. void SetRegionTransparent(BOOL);
  1888. unsigned long GetRegionBackColor();
  1889. void SetRegionBackColor(unsigned long);
  1890. short GetRegionBorderStyle();
  1891. void SetRegionBorderStyle(short);
  1892. unsigned long GetRegionBorderColor();
  1893. void SetRegionBorderColor(unsigned long);
  1894. short GetRegionBorderWidth();
  1895. void SetRegionBorderWidth(short);
  1896. COleFont GetTextFont();
  1897. COleFont GetSymbolFont();
  1898. unsigned long GetTextFontColor();
  1899. void SetTextFontColor(unsigned long);
  1900. unsigned long GetTextFontBackColor();
  1901. void SetTextFontBackColor(unsigned long);
  1902. unsigned long GetSymbolFontColor();
  1903. void SetSymbolFontColor(unsigned long);
  1904. unsigned long GetSymbolFontBackColor();
  1905. void SetSymbolFontBackColor(unsigned long);
  1906. BOOL GetSymbolFontOpaque();
  1907. void SetSymbolFontOpaque(BOOL);
  1908. BOOL GetTextFontOpaque();
  1909. void SetTextFontOpaque(BOOL);
  1910. BOOL GetSymbolFontHalo();
  1911. void SetSymbolFontHalo(BOOL);
  1912. BOOL GetSymbolFontShadow();
  1913. void SetSymbolFontShadow(BOOL);
  1914. BOOL GetTextFontHalo();
  1915. void SetTextFontHalo(BOOL);
  1916. BOOL GetTextFontShadow();
  1917. void SetTextFontShadow(BOOL);
  1918. BOOL GetTextFontAllCaps();
  1919. void SetTextFontAllCaps(BOOL);
  1920. BOOL GetTextFontDblSpace();
  1921. void SetTextFontDblSpace(BOOL);
  1922. BOOL GetSymbolBitmapTransparent();
  1923. void SetSymbolBitmapTransparent(BOOL bNewValue);
  1924. BOOL GetSymbolBitmapOverrideColor();
  1925. void SetSymbolBitmapOverrideColor(BOOL bNewValue);
  1926. unsigned long GetSymbolBitmapColor();
  1927. void SetSymbolBitmapColor(unsigned long nNewValue);
  1928. CString GetSymbolBitmapName();
  1929. void SetSymbolBitmapName(LPCTSTR lpszNewValue);
  1930. short GetSymbolType();
  1931. void SetSymbolType(short nNewValue);
  1932. long GetSymbolBitmapSize();
  1933. void SetSymbolBitmapSize(long nNewValue);
  1934. BOOL GetSupportsBitmapSymbols();
  1935. short GetSymbolFontRotation();
  1936. void SetSymbolFontRotation(short nNewValue);
  1937. long GetLineStyleCount();
  1938. BOOL GetLineInterleaved();
  1939. void SetLineInterleaved(BOOL bNewValue);
  1940. long GetLineWidthUnit();
  1941. void SetLineWidthUnit(long nNewValue);
  1942. long GetRegionBorderWidthUnit();
  1943. void SetRegionBorderWidthUnit(long nNewValue);
  1944. BOOL GetLineSupportsInterleave();
  1945. short GetTextFontRotation();
  1946. void SetTextFontRotation(short propVal);
  1947. unsigned long GetSymbolVectorColor();
  1948. void SetSymbolVectorColor(unsigned long);
  1949. short GetSymbolVectorSize();
  1950. void SetSymbolVectorSize(short);
  1951. short GetMinVectorSymbolCharacter();
  1952. short GetMaxVectorSymbolCharacter();
  1953. // Operations
  1954. public:
  1955. BOOL PickRegion();
  1956. BOOL PickLine();
  1957. BOOL PickText();
  1958. BOOL PickSymbol();
  1959. void DrawTextSample(long hDC, LPDISPATCH Rectangle, LPCTSTR SampleText);
  1960. void DrawSymbolSample(long hDC, LPDISPATCH Rectangle);
  1961. void DrawRegionSample(long hDC, LPDISPATCH Rectangle);
  1962. void DrawLineSample(long hDC, LPDISPATCH Rectangle);
  1963. CMapXStyle Clone();
  1964. void ExportSymbolSample(LPCTSTR Destination, short Format, double Width, double Height, const VARIANT& BackgroundColor);
  1965. void ExportRegionSample(LPCTSTR Destination, short Format, double Width, double Height, const VARIANT& BackgroundColor);
  1966. void ExportLineSample(LPCTSTR Destination, short Format, double Width, double Height, const VARIANT& BackgroundColor);
  1967. void ExportTextSample(LPCTSTR Destination, short Format, double Width, double Height, LPCTSTR SampleText, const VARIANT& BackgroundColor);
  1968. };
  1969. /////////////////////////////////////////////////////////////////////////////
  1970. // CMapXIndividualValueCategory wrapper class
  1971. class CMapXIndividualValueCategory : public COleDispatchDriver
  1972. {
  1973. public:
  1974. CMapXIndividualValueCategory() {} // Calls COleDispatchDriver default constructor
  1975. CMapXIndividualValueCategory(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1976. CMapXIndividualValueCategory(const CMapXIndividualValueCategory& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1977. // Attributes
  1978. public:
  1979. CMapXStyle GetStyle();
  1980. void SetStyle(LPDISPATCH);
  1981. long GetNumItems();
  1982. CString GetValue();
  1983. void SetValue(LPCTSTR);
  1984. // Operations
  1985. public:
  1986. };
  1987. /////////////////////////////////////////////////////////////////////////////
  1988. // CMapXMultivarCategory wrapper class
  1989. class CMapXMultivarCategory : public COleDispatchDriver
  1990. {
  1991. public:
  1992. CMapXMultivarCategory() {} // Calls COleDispatchDriver default constructor
  1993. CMapXMultivarCategory(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  1994. CMapXMultivarCategory(const CMapXMultivarCategory& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  1995. // Attributes
  1996. public:
  1997. CMapXStyle GetStyle();
  1998. void SetStyle(LPDISPATCH);
  1999. // Operations
  2000. public:
  2001. };
  2002. /////////////////////////////////////////////////////////////////////////////
  2003. // CMapXText wrapper class (Same as CMapXGraphic)
  2004. // Used for both Text and Symbol annotations
  2005. // NOTE: ***OBSOLETE***: Do not use this class use CMapXGraphic instead
  2006. class CMapXText : public COleDispatchDriver
  2007. {
  2008. public:
  2009. CMapXText() {} // Calls COleDispatchDriver default constructor
  2010. CMapXText(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2011. CMapXText(const CMapXText& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2012. // Attributes
  2013. public:
  2014. CString GetCaption();
  2015. void SetCaption(LPCTSTR);
  2016. double GetX();
  2017. void SetX(double);
  2018. double GetY();
  2019. void SetY(double);
  2020. short GetPosition();
  2021. void SetPosition(short);
  2022. CMapXStyle GetStyle();
  2023. void SetStyle(LPDISPATCH);
  2024. // Operations
  2025. public:
  2026. };
  2027. /////////////////////////////////////////////////////////////////////////////
  2028. // CMapXGraphic wrapper class (Same as CMapXText)
  2029. // Used for both Text and Symbol annotations
  2030. class CMapXGraphic : public COleDispatchDriver
  2031. {
  2032. public:
  2033. CMapXGraphic() {} // Calls COleDispatchDriver default constructor
  2034. CMapXGraphic(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2035. CMapXGraphic(const CMapXGraphic& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2036. // Attributes
  2037. public:
  2038. CString GetCaption();
  2039. void SetCaption(LPCTSTR);
  2040. double GetX();
  2041. void SetX(double);
  2042. double GetY();
  2043. void SetY(double);
  2044. short GetPosition();
  2045. void SetPosition(short);
  2046. CMapXStyle GetStyle();
  2047. void SetStyle(LPDISPATCH);
  2048. // Operations
  2049. public:
  2050. };
  2051. /////////////////////////////////////////////////////////////////////////////
  2052. // CMapXLegendText wrapper class
  2053. class CMapXLegendText : public COleDispatchDriver
  2054. {
  2055. public:
  2056. CMapXLegendText() {} // Calls COleDispatchDriver default constructor
  2057. CMapXLegendText(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2058. CMapXLegendText(const CMapXLegendText& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2059. // Attributes
  2060. public:
  2061. CString GetText();
  2062. void SetText(LPCTSTR);
  2063.   BOOL GetVisible();
  2064. void SetVisible(BOOL bNewValue);
  2065. // Operations
  2066. public:
  2067. };
  2068. /////////////////////////////////////////////////////////////////////////////
  2069. // CMapXLegendTexts wrapper class
  2070. class CMapXLegendTexts : public COleDispatchDriver
  2071. {
  2072. public:
  2073. CMapXLegendTexts() {} // Calls COleDispatchDriver default constructor
  2074. CMapXLegendTexts(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2075. CMapXLegendTexts(const CMapXLegendTexts& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2076. CMapXLegendText operator[](long Index) { return Item(Index); }
  2077. // Attributes
  2078. public:
  2079. LPENUMVARIANT GetEnumerator();
  2080. BOOL GetAutoGenerate();
  2081. void SetAutoGenerate(BOOL);
  2082. long GetCount();
  2083. CMapXLegendText GetAllOthersText();
  2084. // Operations
  2085. public:
  2086. CMapXLegendText Item(const VARIANT& Index);
  2087. CMapXLegendText Item(long Index) { return Item(COleVariant(Index)); }
  2088. };
  2089. /////////////////////////////////////////////////////////////////////////////
  2090. // CMapXTitle wrapper class
  2091. class CMapXTitle : public COleDispatchDriver
  2092. {
  2093. public:
  2094. CMapXTitle() {} // Calls COleDispatchDriver default constructor
  2095. CMapXTitle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2096. CMapXTitle(const CMapXTitle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2097. // Attributes
  2098. public:
  2099. CString GetCaption();
  2100. void SetCaption(LPCTSTR);
  2101. CMapXStyle GetTextStyle();
  2102. void SetTextStyle(LPDISPATCH);
  2103. BOOL GetVisible();
  2104. void SetVisible(BOOL);
  2105. double GetX();
  2106. void SetX(double);
  2107. double GetY();
  2108. void SetY(double);
  2109. BOOL GetEditable();
  2110. void SetEditable(BOOL);
  2111. short GetPosition();
  2112. void SetPosition(short);
  2113. BOOL GetBorder();
  2114. void SetBorder(BOOL);
  2115. // Operations
  2116. public:
  2117. };
  2118. /////////////////////////////////////////////////////////////////////////////
  2119. // CMapXBindLayer wrapper class
  2120. class CMapXBindLayer : public COleDispatchDriver
  2121. {
  2122. public:
  2123. CMapXBindLayer() {} // Calls COleDispatchDriver default constructor
  2124. CMapXBindLayer(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2125. CMapXBindLayer(const CMapXBindLayer& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2126. const CLSID& GetClsid() const
  2127. {
  2128. static bool bInitialized = false;
  2129. static CLSID clsid;
  2130. if(!bInitialized)
  2131. {
  2132. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".BindLayer.") MAPX_VERSION);
  2133. bInitialized = true;
  2134. }
  2135. return clsid;
  2136. }
  2137. // Attributes
  2138. public:
  2139. CString GetLayerName();
  2140. void SetLayerName(LPCTSTR);
  2141. VARIANT GetRefColumn1();
  2142. void SetRefColumn1(const VARIANT&);
  2143. void SetRefColumn1(long Column) { SetRefColumn1(COleVariant(Column)); }
  2144. void SetRefColumn1(LPCTSTR Column) { SetRefColumn1(COleVariant(Column)); }
  2145. VARIANT GetRefColumn2();
  2146. void SetRefColumn2(const VARIANT&);
  2147. void SetRefColumn2(long Column) { SetRefColumn2(COleVariant(Column)); }
  2148. void SetRefColumn2(LPCTSTR Column) { SetRefColumn2(COleVariant(Column)); }
  2149. short GetLayerType();
  2150. void SetLayerType(short);
  2151. CString GetReferenceLayer();
  2152. void SetReferenceLayer(LPCTSTR);
  2153. CMapXCoordSys GetCoordSys();
  2154. void SetCoordSys(LPDISPATCH);
  2155. CString GetFilespec();
  2156. void SetFilespec(LPCTSTR);
  2157. short GetKeyLength();
  2158. void SetKeyLength(short);
  2159. BOOL GetOverwriteFile();
  2160. void SetOverwriteFile(BOOL);
  2161. long GetReferenceLayerField();
  2162. void SetReferenceLayerField(long);
  2163. // Operations
  2164. public:
  2165. };
  2166. /////////////////////////////////////////////////////////////////////////////
  2167. // CMapXMultivarCategories wrapper class
  2168. class CMapXMultivarCategories : public COleDispatchDriver
  2169. {
  2170. public:
  2171. CMapXMultivarCategories() {} // Calls COleDispatchDriver default constructor
  2172. CMapXMultivarCategories(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2173. CMapXMultivarCategories(const CMapXMultivarCategories& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2174. CMapXMultivarCategory operator[](long Index) { return Item(Index); }
  2175. // Attributes
  2176. public:
  2177. LPENUMVARIANT GetEnumerator();
  2178. long GetCount();
  2179. // Operations
  2180. public:
  2181. CMapXMultivarCategory Item(const VARIANT& Index);
  2182. CMapXMultivarCategory Item(long Index) { return Item(COleVariant(Index)); }
  2183. };
  2184. /////////////////////////////////////////////////////////////////////////////
  2185. // CMapXRangeCategories wrapper class
  2186. class CMapXRangeCategories : public COleDispatchDriver
  2187. {
  2188. public:
  2189. CMapXRangeCategories() {} // Calls COleDispatchDriver default constructor
  2190. CMapXRangeCategories(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2191. CMapXRangeCategories(const CMapXRangeCategories& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2192. CMapXRangeCategory operator[](long Index) { return Item(Index); }
  2193. // Attributes
  2194. public:
  2195. LPENUMVARIANT GetEnumerator();
  2196. long GetCount();
  2197. CMapXRangeCategory GetAllOthersCategory();
  2198. // Operations
  2199. public:
  2200. CMapXRangeCategory Item(const VARIANT& Index);
  2201. CMapXRangeCategory Item(long Index) { return Item(COleVariant(Index)); }
  2202. };
  2203. /////////////////////////////////////////////////////////////////////////////
  2204. // CMapXIndividualValueCategories  wrapper class
  2205. class CMapXIndividualValueCategories : public COleDispatchDriver
  2206. {
  2207. public:
  2208. CMapXIndividualValueCategories () {} // Calls COleDispatchDriver default constructor
  2209. CMapXIndividualValueCategories (LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2210. CMapXIndividualValueCategories (const CMapXIndividualValueCategories & dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2211. CMapXIndividualValueCategory operator[](long Index) { return Item(Index); }
  2212. // Attributes
  2213. public:
  2214. LPENUMVARIANT GetEnumerator();
  2215. long GetCount();
  2216. CMapXIndividualValueCategory GetAllOthersCategory();
  2217. // Operations
  2218. public:
  2219. CMapXIndividualValueCategory Item(const VARIANT& Index);
  2220. CMapXIndividualValueCategory Item(long Index) { return Item(COleVariant(Index)); }
  2221. };
  2222. // CMapXRectangle wrapper class
  2223. class CMapXRectangle : public COleDispatchDriver
  2224. {
  2225. public:
  2226. CMapXRectangle() {} // Calls COleDispatchDriver default constructor
  2227. CMapXRectangle(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2228. CMapXRectangle(const CMapXRectangle& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2229. const CLSID& GetClsid() const
  2230. {
  2231. static bool bInitialized = false;
  2232. static CLSID clsid;
  2233. if(!bInitialized)
  2234. {
  2235. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Rectangle.") MAPX_VERSION);
  2236. bInitialized = true;
  2237. }
  2238. return clsid;
  2239. }
  2240. // Attributes
  2241. public:
  2242. double GetXMin();
  2243. double GetYMin();
  2244. double GetXMax();
  2245. double GetYMax();
  2246. double GetHeight();
  2247. double GetWidth();
  2248. // Operations
  2249. public:
  2250. void Set(double X1, double Y1, double X2, double Y2);
  2251. void Offset(double deltaX, double deltaY);
  2252. };
  2253. /////////////////////////////////////////////////////////////////////////////
  2254. // CMapXFindFeature wrapper class
  2255. class CMapXFindFeature : public COleDispatchDriver
  2256. {
  2257. public:
  2258. CMapXFindFeature() {} // Calls COleDispatchDriver default constructor
  2259. CMapXFindFeature(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2260. CMapXFindFeature(const CMapXFindFeature& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2261. // Attributes
  2262. public:
  2263. long GetFeatureID();
  2264. short GetType();
  2265. void SetType(short);
  2266. double GetLength();
  2267. double GetCenterX();
  2268. double GetCenterY();
  2269. CMapXStyle GetStyle();
  2270. void SetStyle(LPDISPATCH);
  2271. CMapXRectangle GetBounds();
  2272. CString GetCaption();
  2273. void SetCaption(LPCTSTR);
  2274. CMapXParts GetParts();
  2275. double GetArea();
  2276. CMapXLayer GetLayer();
  2277. CMapXPoint GetPoint();
  2278. void SetPoint(LPDISPATCH);
  2279. CMapXPoint GetLabelPoint();
  2280. double GetPerimeter();
  2281. BOOL GetSmooth();
  2282. void SetSmooth(BOOL);
  2283. CString GetName();
  2284. CString GetKeyValue();
  2285. void SetKeyValue(LPCTSTR);
  2286. CString GetFeatureKey();
  2287. LPDISPATCH GetRegion();
  2288. void SetRegion(LPDISPATCH);
  2289. LPDISPATCH GetPolyline();
  2290. void SetPolyline(LPDISPATCH);
  2291. LPDISPATCH GetMultipoint();
  2292. void SetMultipoint(LPDISPATCH);
  2293. BOOL GetHasRegion();
  2294. BOOL GetHasPolyline();
  2295. BOOL GetHasMultipoint();
  2296. short GetFindRC();
  2297. // Operations
  2298. public:
  2299. void Update(const VARIANT& UpdateFeature, const VARIANT& RowValues);
  2300. void Update()
  2301. {
  2302. Update(COptionalVariant(), COptionalVariant());
  2303. }
  2304. void Offset(double deltaX, double deltaY);
  2305. void Attach(LPDISPATCH Map);
  2306. LPDISPATCH Clone();
  2307. VARIANT GetNodes(const VARIANT& CSys);
  2308. void SetNodes(const VARIANT& CSys, const VARIANT& newValue);
  2309. };
  2310. /////////////////////////////////////////////////////////////////////////////
  2311. // CMapXFindResult wrapper class
  2312. class CMapXFindResult : public COleDispatchDriver
  2313. {
  2314. public:
  2315. CMapXFindResult() {} // Calls COleDispatchDriver default constructor
  2316. CMapXFindResult(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2317. CMapXFindResult(const CMapXFindResult& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2318. // Attributes
  2319. public:
  2320. BOOL GetExactMatch();
  2321. BOOL GetSubstitute();
  2322. BOOL GetAddressOutOfRange();
  2323. BOOL GetIntersectionNotFound();
  2324. BOOL GetMultipleMatches();
  2325. BOOL GetRefineRegion();
  2326. short GetFindRC();
  2327. CMapXFindMatches GetMatches();
  2328. CMapXFeature GetMatchedFeature();
  2329. };
  2330. /////////////////////////////////////////////////////////////////////////////
  2331. // CMapXLayerFind wrapper class
  2332. class CMapXLayerFind : public COleDispatchDriver
  2333. {
  2334. public:
  2335. CMapXLayerFind() {} // Calls COleDispatchDriver default constructor
  2336. CMapXLayerFind(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2337. CMapXLayerFind(const CMapXLayerFind& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2338. // Attributes
  2339. public:
  2340. CMapXLayer GetRefineLayer();
  2341. void SetRefineLayer(LPDISPATCH);
  2342. BOOL GetAbbreviations();
  2343. void SetAbbreviations(BOOL);
  2344. BOOL GetClosestAddr();
  2345. void SetClosestAddr(BOOL);
  2346. BOOL GetOtherBoundary();
  2347. void SetOtherBoundary(BOOL);
  2348. CMapXField GetFindField();
  2349. void SetFindField(LPDISPATCH);
  2350. CMapXField GetRefineField();
  2351. void SetRefineField(LPDISPATCH);
  2352. CMapXDataset GetFindDataset();
  2353. void SetFindDataset(LPDISPATCH);
  2354. CMapXDataset GetRefineDataset();
  2355. void SetRefineDataset(LPDISPATCH);
  2356. long GetCloseMatchMax();
  2357. void SetCloseMatchMax(long);
  2358. // Operations
  2359. public:
  2360. CMapXFindFeature Search(LPCTSTR Address, const VARIANT& RefineBoundary);
  2361. CMapXFindFeature Search(LPCTSTR Address, LPCTSTR RefineBoundary)
  2362. { return Search(Address, COleVariant(RefineBoundary)); }
  2363. CMapXFindFeature Search(LPCTSTR Address)
  2364. { return Search(Address, COptionalVariant()); }
  2365. CMapXFindResult SearchEx(LPCTSTR Address, const VARIANT& RefineBoundary);
  2366. CMapXFindResult SearchEx(LPCTSTR Address, LPCTSTR RefineBoundary)
  2367. { return SearchEx(Address, COleVariant(RefineBoundary)); }
  2368. CMapXFindResult SearchEx(LPCTSTR Address)
  2369. { return SearchEx(Address, COptionalVariant()); }
  2370. };
  2371. /////////////////////////////////////////////////////////////////////////////
  2372. // CMapXFindMatch wrapper class
  2373. class CMapXFindMatch : public COleDispatchDriver
  2374. {
  2375. public:
  2376. CMapXFindMatch() {} // Calls COleDispatchDriver default constructor
  2377. CMapXFindMatch(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2378. CMapXFindMatch(const CMapXFindMatch& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2379. // Attributes
  2380. public:
  2381. long GetFeatureID();
  2382. CString GetName();
  2383. long GetScore();
  2384. CString GetFeatureKey();
  2385. };
  2386. /////////////////////////////////////////////////////////////////////////////
  2387. // CMapXFindMatches wrapper class
  2388. class CMapXFindMatches : public COleDispatchDriver
  2389. {
  2390. public:
  2391. CMapXFindMatches() {} // Calls COleDispatchDriver default constructor
  2392. CMapXFindMatches(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2393. CMapXFindMatches(const CMapXFindMatches& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2394. CMapXFindMatch operator[](long Index) { return Item(Index); }
  2395. // Attributes
  2396. public:
  2397. LPENUMVARIANT GetEnumerator();
  2398. long GetCount();
  2399. // Operations
  2400. public:
  2401. CMapXFindMatch Item(const VARIANT& Index);
  2402. CMapXFindMatch Item(long Index) { return Item(COleVariant(Index)); }
  2403. };
  2404. /////////////////////////////////////////////////////////////////////////////
  2405. // CMapXGeoset wrapper class
  2406. class CMapXGeoset : public COleDispatchDriver
  2407. {
  2408. public:
  2409. CMapXGeoset() {} // Calls COleDispatchDriver default constructor
  2410. CMapXGeoset(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2411. CMapXGeoset(const CMapXGeoset& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2412. // Attributes
  2413. public:
  2414. CMapXPoint GetCentroid();
  2415. CString GetPathName();
  2416. CString GetUserName();
  2417. // Operations
  2418. public:
  2419. };
  2420. /////////////////////////////////////////////////////////////////////////////
  2421. // CMapXGeosets wrapper class
  2422. class CMapXGeosets : public COleDispatchDriver
  2423. {
  2424. public:
  2425. CMapXGeosets() {} // Calls COleDispatchDriver default constructor
  2426. CMapXGeosets(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2427. CMapXGeosets(const CMapXGeosets& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2428. CMapXGeoset operator[](long Index) { return Item(Index); }
  2429. CMapXGeoset operator[](LPCTSTR Index) { return Item(Index); }
  2430. // Attributes
  2431. public:
  2432. LPENUMVARIANT GetEnumerator();
  2433. long GetCount();
  2434. // Operations
  2435. public:
  2436. CMapXGeoset Item(const VARIANT& Index);
  2437. CMapXGeoset Item(long Index) { return Item(COleVariant(Index)); }
  2438. CMapXGeoset Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
  2439. };
  2440. /////////////////////////////////////////////////////////////////////////////
  2441. // CMapXPoint wrapper class
  2442. class CMapXPoint : public COleDispatchDriver
  2443. {
  2444. public:
  2445. CMapXPoint() {} // Calls COleDispatchDriver default constructor
  2446. CMapXPoint(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2447. CMapXPoint(const CMapXPoint& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2448. const CLSID& GetClsid() const
  2449. {
  2450. static bool bInitialized = false;
  2451. static CLSID clsid;
  2452. if(!bInitialized)
  2453. {
  2454. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Point.") MAPX_VERSION);
  2455. bInitialized = true;
  2456. }
  2457. return clsid;
  2458. }
  2459. // Attributes
  2460. public:
  2461. double GetX();
  2462. double GetY();
  2463. // Operations
  2464. public:
  2465. void Set(double X, double Y);
  2466. void Offset(double deltaX, double deltaY);
  2467. };
  2468. /////////////////////////////////////////////////////////////////////////////
  2469. // CMapXPoints wrapper class
  2470. class CMapXPoints : public COleDispatchDriver
  2471. {
  2472. public:
  2473. CMapXPoints() {} // Calls COleDispatchDriver default constructor
  2474. CMapXPoints(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2475. CMapXPoints(const CMapXPoints& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2476. CMapXPoint operator[](long Index) { return Item(Index); }
  2477. const CLSID& GetClsid() const
  2478. {
  2479. static bool bInitialized = false;
  2480. static CLSID clsid;
  2481. if(!bInitialized)
  2482. {
  2483. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Points.") MAPX_VERSION);
  2484. bInitialized = true;
  2485. }
  2486. return clsid;
  2487. }
  2488. // Attributes
  2489. public:
  2490. LPENUMVARIANT GetEnumerator();
  2491. long GetCount();
  2492. // Operations
  2493. public:
  2494. CMapXPoint Item(const VARIANT& Index);
  2495. CMapXPoint Item(long Index) { return Item(COleVariant(Index)); }
  2496. void Remove(const VARIANT& Index);
  2497. void Remove(long Index) { Remove(COleVariant(Index)); }
  2498. CMapXPoint Add(LPDISPATCH Point, const VARIANT& Position);
  2499. CMapXPoint Add(LPDISPATCH Point, short Position) { return Add(Point, COleVariant(Position)); }
  2500. CMapXPoint Add(LPDISPATCH Point) { return Add(Point, COptionalVariant()); }
  2501. CMapXPoint AddXY(double X, double Y, const VARIANT& Position);
  2502. CMapXPoint AddXY(double X, double Y) { return AddXY(X,Y, COptionalVariant()); }
  2503. CMapXPoint AddXY(double X, double Y, short Position) { return AddXY(X,Y, COleVariant(Position)); }
  2504. void RemoveAll();
  2505. void GetXY(long Index, double *dX, double *dY);
  2506. double X(long Index);
  2507. double Y(long Index);
  2508. };
  2509. /////////////////////////////////////////////////////////////////////////////
  2510. // CMapXParts wrapper class
  2511. class CMapXParts : public COleDispatchDriver
  2512. {
  2513. public:
  2514. CMapXParts() {} // Calls COleDispatchDriver default constructor
  2515. CMapXParts(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2516. CMapXParts(const CMapXParts& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2517. CMapXPoints operator[](long Index) { return Item(Index); }
  2518. const CLSID& GetClsid() const
  2519. {
  2520. static bool bInitialized = false;
  2521. static CLSID clsid;
  2522. if(!bInitialized)
  2523. {
  2524. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Parts.") MAPX_VERSION);
  2525. bInitialized = true;
  2526. }
  2527. return clsid;
  2528. }
  2529. // Attributes
  2530. public:
  2531. LPENUMVARIANT GetEnumerator();
  2532. long GetCount();
  2533. // Operations
  2534. public:
  2535. CMapXPoints Add(LPDISPATCH Points);
  2536. CMapXPoints Add() { return Add(NULL); }
  2537. CMapXPoints Item(const VARIANT& Index);
  2538. CMapXPoints Item(long Index) { return Item(COleVariant(Index)); }
  2539. void Remove(const VARIANT& Index);
  2540. void Remove(long Index) { Remove(COleVariant(Index)); }
  2541. void RemoveAll();
  2542. };
  2543. /////////////////////////////////////////////////////////////////////////////
  2544. // CMapXNotesViewInfo wrapper class
  2545. class CMapXNotesViewInfo : public COleDispatchDriver
  2546. {
  2547. public:
  2548. CMapXNotesViewInfo() {} // Calls COleDispatchDriver default constructor
  2549. CMapXNotesViewInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2550. CMapXNotesViewInfo(const CMapXNotesViewInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2551. const CLSID& GetClsid() const
  2552. {
  2553. static bool bInitialized = false;
  2554. static CLSID clsid;
  2555. if(!bInitialized)
  2556. {
  2557. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".NotesViewInfo.") MAPX_VERSION);
  2558. bInitialized = true;
  2559. }
  2560. return clsid;
  2561. }
  2562. // Attributes
  2563. public:
  2564. CString GetServer();
  2565. void SetServer(LPCTSTR);
  2566. CString GetDatabase();
  2567. void SetDatabase(LPCTSTR);
  2568. CString GetView();
  2569. void SetView(LPCTSTR);
  2570. // Operations
  2571. public:
  2572. };
  2573. /////////////////////////////////////////////////////////////////////////////
  2574. // CMapXNotesQueryInfo wrapper class
  2575. class CMapXNotesQueryInfo : public COleDispatchDriver
  2576. {
  2577. public:
  2578. CMapXNotesQueryInfo() {} // Calls COleDispatchDriver default constructor
  2579. CMapXNotesQueryInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2580. CMapXNotesQueryInfo(const CMapXNotesQueryInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2581. const CLSID& GetClsid() const
  2582. {
  2583. static bool bInitialized = false;
  2584. static CLSID clsid;
  2585. if(!bInitialized)
  2586. {
  2587. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".NotesQueryInfo.") MAPX_VERSION);
  2588. bInitialized = true;
  2589. }
  2590. return clsid;
  2591. }
  2592. // Attributes
  2593. public:
  2594. CString GetServer();
  2595. void SetServer(LPCTSTR);
  2596. CString GetDatabase();
  2597. void SetDatabase(LPCTSTR);
  2598. CString GetQuery();
  2599. void SetQuery(LPCTSTR);
  2600. CString GetBeginDate();
  2601. void SetBeginDate(LPCTSTR);
  2602. CString GetEndDate();
  2603. void SetEndDate(LPCTSTR);
  2604. BOOL GetFullTextSearch();
  2605. void SetFullTextSearch(BOOL);
  2606. CString GetDefaultStringValue();
  2607. void SetDefaultStringValue(LPCTSTR);
  2608. double GetDefaultNumericValue();
  2609. void SetDefaultNumericValue(double);
  2610. long GetMaxNumDocs();
  2611. void SetMaxNumDocs(long);
  2612. // Operations
  2613. public:
  2614. };
  2615. /////////////////////////////////////////////////////////////////////////////
  2616. // CMapXODBCQueryInfo wrapper class
  2617. class CMapXODBCQueryInfo : public COleDispatchDriver
  2618. {
  2619. public:
  2620. CMapXODBCQueryInfo() {} // Calls COleDispatchDriver default constructor
  2621. CMapXODBCQueryInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2622. CMapXODBCQueryInfo(const CMapXODBCQueryInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2623. const CLSID& GetClsid() const
  2624. {
  2625. static bool bInitialized = false;
  2626. static CLSID clsid;
  2627. if(!bInitialized)
  2628. {
  2629. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".ODBCQueryInfo.") MAPX_VERSION);
  2630. bInitialized = true;
  2631. }
  2632. return clsid;
  2633. }
  2634. // Attributes
  2635. public:
  2636. CString GetDataSource();
  2637. void SetDataSource(LPCTSTR);
  2638. CString GetSqlQuery();
  2639. void SetSqlQuery(LPCTSTR);
  2640. CString GetConnectString();
  2641. void SetConnectString(LPCTSTR);
  2642. // Operations
  2643. public:
  2644. };
  2645. /////////////////////////////////////////////////////////////////////////////
  2646. // CMapXOCIQueryInfo wrapper class
  2647. class CMapXOCIQueryInfo : public COleDispatchDriver
  2648. {
  2649. public:
  2650. CMapXOCIQueryInfo() {} // Calls COleDispatchDriver default constructor
  2651. CMapXOCIQueryInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2652. CMapXOCIQueryInfo(const CMapXOCIQueryInfo& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2653. const CLSID& GetClsid() const
  2654. {
  2655. static bool bInitialized = false;
  2656. static CLSID clsid;
  2657. if(!bInitialized)
  2658. {
  2659. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".OCIQueryInfo.") MAPX_VERSION);
  2660. bInitialized = true;
  2661. }
  2662. return clsid;
  2663. }
  2664. // Attributes
  2665. public:
  2666. CString GetSqlQuery();
  2667. void SetSqlQuery(LPCTSTR);
  2668. CString GetConnectString();
  2669. void SetConnectString(LPCTSTR);
  2670. // Operations
  2671. public:
  2672. };
  2673. /////////////////////////////////////////////////////////////////////////////
  2674. // CMapXDatum wrapper class
  2675. class CMapXDatum : public COleDispatchDriver
  2676. {
  2677. public:
  2678. CMapXDatum() {} // Calls COleDispatchDriver default constructor
  2679. CMapXDatum(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2680. CMapXDatum(const CMapXDatum& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2681. const CLSID& GetClsid() const
  2682. {
  2683. static bool bInitialized = false;
  2684. static CLSID clsid;
  2685. if(!bInitialized)
  2686. {
  2687. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Datum.") MAPX_VERSION);
  2688. bInitialized = true;
  2689. }
  2690. return clsid;
  2691. }
  2692. // Attributes
  2693. public:
  2694. short GetEllipsoid();
  2695. double GetShiftX();
  2696. double GetShiftY();
  2697. double GetShiftZ();
  2698. double GetRotateX();
  2699. double GetRotateY();
  2700. double GetRotateZ();
  2701. double GetScaleAdjust();
  2702. double GetPrimeMeridian();
  2703. double GetSemiMajorAxis();
  2704. double GetSemiMinorAxis();
  2705. double GetFlattening();
  2706. double GetEccentricity();
  2707. // Operations
  2708. public:
  2709. void Set(short Ellipsoid, double ShiftX, double ShiftY, double ShiftZ, double RotateX, double RotateY, double RotateZ, double ScaleAdjust, double PrimeMeridian);
  2710. void SetFromList(short DatumNum);
  2711. };
  2712. /////////////////////////////////////////////////////////////////////////////
  2713. // CMapXAffineTransform wrapper class
  2714. class CMapXAffineTransform : public COleDispatchDriver
  2715. {
  2716. public:
  2717. CMapXAffineTransform() {} // Calls COleDispatchDriver default constructor
  2718. CMapXAffineTransform(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2719. CMapXAffineTransform(const CMapXAffineTransform& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2720. const CLSID& GetClsid() const
  2721. {
  2722. static bool bInitialized = false;
  2723. static CLSID clsid;
  2724. if(!bInitialized)
  2725. {
  2726. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".AffineTransform.") MAPX_VERSION);
  2727. bInitialized = true;
  2728. }
  2729. return clsid;
  2730. }
  2731. // Attributes
  2732. public:
  2733. short GetUnits();
  2734. double GetA();
  2735. double GetB();
  2736. double GetC();
  2737. double GetD();
  2738. double GetE();
  2739. double GetF();
  2740. // Operations
  2741. public:
  2742. void Set(short Units, double A, double B, double C, double D, double E, double F);
  2743. };
  2744. /////////////////////////////////////////////////////////////////////////////
  2745. // CMapXCoordSys wrapper class
  2746. class CMapXCoordSys : public COleDispatchDriver
  2747. {
  2748. public:
  2749. CMapXCoordSys() {} // Calls COleDispatchDriver default constructor
  2750. CMapXCoordSys(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2751. CMapXCoordSys(const CMapXCoordSys& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2752. const CLSID& GetClsid() const
  2753. {
  2754. static bool bInitialized = false;
  2755. static CLSID clsid;
  2756. if(!bInitialized)
  2757. {
  2758. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".CoordSys.") MAPX_VERSION);
  2759. bInitialized = true;
  2760. }
  2761. return clsid;
  2762. }
  2763. // Attributes
  2764. public:
  2765. short GetType();
  2766. CMapXDatum GetDatum();
  2767. short GetUnits();
  2768. CMapXRectangle GetBounds();
  2769. double GetOriginLongitude();
  2770. double GetOriginLatitude();
  2771. double GetStandardParallelOne();
  2772. double GetStandardParallelTwo();
  2773. double GetAzimuth();
  2774. double GetScaleFactor();
  2775. double GetFalseEasting();
  2776. double GetFalseNorthing();
  2777. double GetRange();
  2778. CMapXAffineTransform GetAffineTransform();
  2779. // Operations
  2780. public:
  2781. void Set(short Type, const VARIANT& Datum, const VARIANT& Units, const VARIANT& OriginLongitude, const VARIANT& OriginLatitude, const VARIANT& StandardParallelOne, const VARIANT& StandardParallelTwo, const VARIANT& Azimuth,
  2782. const VARIANT& ScaleFactor, const VARIANT& FalseEasting, const VARIANT& FalseNorthing, const VARIANT& Range, const VARIANT& Bounds, const VARIANT& AffineTransform);
  2783. void Set(short Type, LPDISPATCH Datum, const VARIANT& Units, const VARIANT& OriginLongitude, const VARIANT& OriginLatitude, const VARIANT& StandardParallelOne, const VARIANT& StandardParallelTwo, const VARIANT& Azimuth,
  2784. const VARIANT& ScaleFactor, const VARIANT& FalseEasting, const VARIANT& FalseNorthing, const VARIANT& Range, const VARIANT& Bounds, const VARIANT& AffineTransform)
  2785. {
  2786. Set(Type, COleVariantDispatch(Datum), Units, OriginLongitude, OriginLatitude, StandardParallelOne,
  2787. StandardParallelTwo, Azimuth, ScaleFactor, FalseEasting, FalseNorthing, Range, Bounds,
  2788. AffineTransform);
  2789. }
  2790. void Set(short Type, short Datum, const VARIANT& Units, const VARIANT& OriginLongitude, const VARIANT& OriginLatitude, const VARIANT& StandardParallelOne, const VARIANT& StandardParallelTwo, const VARIANT& Azimuth,
  2791. const VARIANT& ScaleFactor, const VARIANT& FalseEasting, const VARIANT& FalseNorthing, const VARIANT& Range, const VARIANT& Bounds, const VARIANT& AffineTransform)
  2792. {
  2793. Set(Type, COleVariant(Datum), Units, OriginLongitude, OriginLatitude, StandardParallelOne,
  2794. StandardParallelTwo, Azimuth, ScaleFactor, FalseEasting, FalseNorthing, Range, Bounds,
  2795. AffineTransform);
  2796. }
  2797. BOOL PickCoordSys(const VARIANT& HelpFile, const VARIANT& HelpID);
  2798. BOOL PickCoordSys(LPCTSTR HelpFile, UINT HelpID=HELP_FINDER)
  2799. { return PickCoordSys(COleVariant(HelpFile), COleVariant((long)HelpID)); }
  2800. BOOL PickCoordSys()
  2801. { return PickCoordSys(COptionalVariant(), COptionalVariant()); }
  2802. CMapXCoordSys Clone();
  2803. };
  2804. /////////////////////////////////////////////////////////////////////////////
  2805. // CMapXBitmapSymbol wrapper class
  2806. class CMapXBitmapSymbol : public COleDispatchDriver
  2807. {
  2808. public:
  2809. CMapXBitmapSymbol() {} // Calls COleDispatchDriver default constructor
  2810. CMapXBitmapSymbol(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2811. CMapXBitmapSymbol(const CMapXBitmapSymbol& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2812. // Attributes
  2813. public:
  2814. CString GetName();
  2815. };
  2816. /////////////////////////////////////////////////////////////////////////////
  2817. // CMapXBitmapSymbols wrapper class
  2818. class CMapXBitmapSymbols : public COleDispatchDriver
  2819. {
  2820. public:
  2821. CMapXBitmapSymbols() {} // Calls COleDispatchDriver default constructor
  2822. CMapXBitmapSymbols(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2823. CMapXBitmapSymbols(const CMapXBitmapSymbols& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2824. const CLSID& GetClsid() const
  2825. {
  2826. static bool bInitialized = false;
  2827. static CLSID clsid;
  2828. if(!bInitialized)
  2829. {
  2830. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".BitmapSymbols.") MAPX_VERSION);
  2831. bInitialized = true;
  2832. }
  2833. return clsid;
  2834. }
  2835. // Attributes
  2836. public:
  2837. LPENUMVARIANT GetEnumerator();
  2838. long GetCount();
  2839. CMapXBitmapSymbol operator[](long Index) { return Item(Index); }
  2840. // Operations
  2841. public:
  2842. CMapXBitmapSymbol Item(const VARIANT& Index);
  2843. CMapXBitmapSymbol Item(long Index) { return Item(COleVariant(Index)); }
  2844. void Refresh();
  2845. void Unload();
  2846. // Operations
  2847. public:
  2848. };
  2849. /////////////////////////////////////////////////////////////////////////////
  2850. // CMapXFeatureFactory wrapper class
  2851. class CMapXFeatureFactory : public COleDispatchDriver
  2852. {
  2853. public:
  2854. CMapXFeatureFactory() {} // Calls COleDispatchDriver default constructor
  2855. CMapXFeatureFactory(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2856. CMapXFeatureFactory(const CMapXFeatureFactory& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2857. // Attributes
  2858. public:
  2859. // Operations
  2860. public:
  2861. CMapXFeature BufferFeatures(LPDISPATCH Source, double Distance, const VARIANT& Units, const VARIANT& Resolution);
  2862. CMapXFeature BufferFeatures(LPDISPATCH Source, double Distance, short Units, short Resolution)
  2863. { return BufferFeatures(Source, Distance, COleVariant(Units), COleVariant(Resolution));}
  2864. CMapXFeature BufferFeatures(LPDISPATCH Source, double Distance, short Units)
  2865. { return BufferFeatures(Source, Distance, COleVariant(Units), COptionalVariant());}
  2866. CMapXFeature CombineFeatures(LPDISPATCH Source1, const VARIANT& Source2);
  2867. CMapXFeature CombineFeatures(LPDISPATCH Source1)
  2868. { return CombineFeatures(Source1, COptionalVariant()); }
  2869. CMapXFeature IntersectFeatures(LPDISPATCH Source1, const VARIANT& Source2);
  2870. CMapXFeature IntersectFeatures(LPDISPATCH Source1)
  2871. { return IntersectFeatures(Source1, COptionalVariant()); }
  2872. CMapXFeature EraseFeature(LPDISPATCH Feature, LPDISPATCH EraserFeature);
  2873. CMapXFeature CreateSymbol(const VARIANT& Point, const VARIANT& Style);
  2874. CMapXFeature CreateSymbol(const VARIANT& Point)
  2875. { return CreateSymbol(Point, COptionalVariant());}
  2876. CMapXFeature CreateSymbol()
  2877. { return CreateSymbol(COptionalVariant(), COptionalVariant());}
  2878. CMapXFeature CreateRegion(const VARIANT& Points, const VARIANT& Style);
  2879. CMapXFeature CreateRegion(const VARIANT& Points)
  2880. { return CreateRegion(Points, COptionalVariant());}
  2881. CMapXFeature CreateRegion()
  2882. { return CreateRegion(COptionalVariant(), COptionalVariant());}
  2883. CMapXFeature CreateLine(const VARIANT& Points, const VARIANT& Style);
  2884. CMapXFeature CreateLine(const VARIANT& Points)
  2885. { return CreateLine(Points, COptionalVariant());}
  2886. CMapXFeature CreateLine()
  2887. { return CreateLine(COptionalVariant(), COptionalVariant());}
  2888. CMapXFeature CreateText(const VARIANT& Point, const VARIANT& Caption, const VARIANT& Position, const VARIANT& Style);
  2889. CMapXFeature CreateText(const VARIANT& Point, LPCTSTR Caption, short Position, const VARIANT& Style)
  2890. { return CreateText(Point, COleVariant(Caption), COleVariant(Position), Style);}
  2891. CMapXFeature CreateText(const VARIANT& Point, LPCTSTR Caption=_T(""), short Position=miPositionTL)
  2892. { return CreateText(Point, COleVariant(Caption), COleVariant(Position), COptionalVariant());}
  2893. CMapXFeature CreateText(LPCTSTR Caption=_T(""), short Position=miPositionTL)
  2894. { return CreateText(COptionalVariant(), COleVariant(Caption), COleVariant(Position), COptionalVariant());}
  2895. CMapXFeature CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, const VARIANT& Angle, const VARIANT& Distance, const VARIANT& Resolution, const VARIANT& Style);
  2896. CMapXFeature CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, double Angle, double Distance, short Resolution)
  2897. { return CreateArc(Point1, Point2, COleVariant(Angle), COleVariant(Distance), COleVariant(Resolution), COptionalVariant());}
  2898. CMapXFeature CreateArc(LPDISPATCH Point1, LPDISPATCH Point2, double Angle=90.0, double Distance=1.0)
  2899. { return CreateArc(Point1, Point2, COleVariant(Angle), COleVariant(Distance), COptionalVariant(), COptionalVariant());}
  2900. CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, const VARIANT& Angle, const VARIANT& Resolution, const VARIANT& Style);
  2901. CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, double Angle=0.0)
  2902. { return CreateEllipticalRegion(Rectangle, COleVariant(Angle), COptionalVariant(), COptionalVariant());}
  2903. CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, short Resolution)
  2904. { return CreateEllipticalRegion(Rectangle, COptionalVariant(), COleVariant(Resolution), COptionalVariant());}
  2905. CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, LPDISPATCH Style)
  2906. {
  2907. return CreateEllipticalRegion(Rectangle, COptionalVariant(), COptionalVariant(), COleVariantDispatch(Style));
  2908. }
  2909. CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, double Angle, short Resolution)
  2910. { return CreateEllipticalRegion(Rectangle, COleVariant(Angle), COleVariant(Resolution), COptionalVariant());}
  2911. CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, double Angle, LPDISPATCH Style)
  2912. {
  2913. return CreateEllipticalRegion(Rectangle, COleVariant(Angle), COptionalVariant(), COleVariantDispatch(Style));
  2914. }
  2915. CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, short Resolution, LPDISPATCH Style)
  2916. {
  2917. return CreateEllipticalRegion(Rectangle, COptionalVariant(), COleVariant(Resolution), COleVariantDispatch(Style));
  2918. }
  2919. CMapXFeature CreateEllipticalRegion(LPDISPATCH Rectangle, double Angle, short Resolution, LPDISPATCH Style)
  2920. {
  2921. return CreateEllipticalRegion(Rectangle, COleVariant(Angle), COleVariant(Resolution), COleVariantDispatch(Style));
  2922. }
  2923. CMapXFeature CreateCircularRegion(short Type, LPDISPATCH Point, double Distance, const VARIANT& Units, const VARIANT& Resolution, const VARIANT& Style);
  2924. CMapXFeature CreateCircularRegion(short Type, LPDISPATCH Point, double Distance, short Units, short Resolution)
  2925. { return CreateCircularRegion(Type, Point, Distance, COleVariant(Units), COleVariant(Resolution), COptionalVariant());}
  2926. CMapXFeature CreateCircularRegion(short Type, LPDISPATCH Point, double Distance, short Units)
  2927. { return CreateCircularRegion(Type, Point, Distance, COleVariant(Units), COptionalVariant(), COptionalVariant());}
  2928. BOOL IntersectionTest(LPDISPATCH Feature1, LPDISPATCH Feature2, const VARIANT& Flag);
  2929. BOOL IntersectionTest(LPDISPATCH Feature1, LPDISPATCH Feature2, short Flag=miIntersectFeature)
  2930. { return IntersectionTest(Feature1, Feature2, COleVariant(Flag)); }
  2931. CMapXPoints IntersectionPoints(LPDISPATCH Feature1, LPDISPATCH Feature2, const VARIANT& Flag);
  2932. CMapXPoints IntersectionPoints(LPDISPATCH Feature1, LPDISPATCH Feature2, short Flag=miIntersectAll)
  2933. { return IntersectionPoints(Feature1, Feature2, COleVariant(Flag)); }
  2934. CMapXFeature CreateCollectionFeature(const VARIANT& Source1, const VARIANT& Source2, const VARIANT& Source3);
  2935. CMapXFeature CreateCollectionFeature(const VARIANT& Source1, const VARIANT& Source2)
  2936. { return CreateCollectionFeature(Source1, Source2, COptionalVariant()); }
  2937. CMapXFeature CreateCollectionFeature(const VARIANT& Source1)
  2938. { return CreateCollectionFeature(Source1, COptionalVariant(), COptionalVariant()); }
  2939. CMapXFeature CreateCollectionFeature()
  2940. { return CreateCollectionFeature(COptionalVariant(), COptionalVariant(), COptionalVariant()); }
  2941. CMapXFeature CreateMultipoint(const VARIANT& Points, const VARIANT& Style);
  2942. CMapXFeature CreateMultipoint(const VARIANT& Points)
  2943. { return CreateMultipoint(Points, COptionalVariant());}
  2944. CMapXFeature CreateMultipoint()
  2945. { return CreateMultipoint(COptionalVariant(), COptionalVariant());}
  2946. };
  2947. class CMapXResolveObject : public COleDispatchDriver
  2948. {
  2949. public:
  2950. CMapXResolveObject() {} // Calls COleDispatchDriver default constructor
  2951. CMapXResolveObject(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2952. CMapXResolveObject(const CMapXResolveObject& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2953. // Attributes
  2954. public:
  2955. CString GetTableName();
  2956. long GetSourceMatch();
  2957. long GetTableMatch();
  2958. // Operations
  2959. public:
  2960. };
  2961. class CMapXResolveObjects : public COleDispatchDriver
  2962. {
  2963. public:
  2964. CMapXResolveObjects() {} // Calls COleDispatchDriver default constructor
  2965. CMapXResolveObjects(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2966. CMapXResolveObjects(const CMapXResolveObjects& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2967. // Attributes
  2968. public:
  2969. LPENUMVARIANT GetEnumerator();
  2970. long GetCount();
  2971. CMapXResolveObject operator[](long Index) { return Item(Index); }
  2972. // Operations
  2973. public:
  2974. CMapXResolveObject Item(const VARIANT& Index);
  2975. CMapXResolveObject Item(long Index) { return Item(COleVariant(Index)); }
  2976. };
  2977. /////////////////////////////////////////////////////////////////////////////
  2978. // CMapXLayerInfo wrapper class
  2979. class CMapXLayerInfo : public COleDispatchDriver
  2980. {
  2981. public:
  2982. CMapXLayerInfo() {} // Calls COleDispatchDriver default constructor
  2983. CMapXLayerInfo(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  2984. CMapXLayerInfo(const CMapXRowValue& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  2985. const CLSID& GetClsid() const
  2986. {
  2987. static bool bInitialized = false;
  2988. static CLSID clsid;
  2989. if(!bInitialized)
  2990. {
  2991. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".LayerInfo.") MAPX_VERSION);
  2992. bInitialized = true;
  2993. }
  2994. return clsid;
  2995. }
  2996. // Attributes
  2997. public:
  2998. short GetType();
  2999. void SetType(short);
  3000. // Operations
  3001. public:
  3002. void AddParameter(LPCTSTR ParamName, const VARIANT& Param);
  3003. };
  3004. /////////////////////////////////////////////////////////////////////////////
  3005. // CMapXVariable wrapper class
  3006. class CMapXVariable : public COleDispatchDriver
  3007. {
  3008. public:
  3009. CMapXVariable() {} // Calls COleDispatchDriver default constructor
  3010. CMapXVariable(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  3011. CMapXVariable(const CMapXVariable& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  3012. // Attributes
  3013. public:
  3014. CString GetName();
  3015. VARIANT GetValue();
  3016. void SetValue(const VARIANT&);
  3017. void SetValue(short n)
  3018. { SetValue(COleVariant(n)); }
  3019. void SetValue(long n)
  3020. { SetValue(COleVariant(n)); }
  3021. void SetValue(double d)
  3022. { SetValue(COleVariant(d)); }
  3023. void SetValue(const TCHAR *pszValue)
  3024. { SetValue(COleVariant(pszValue)); }
  3025. // Operations
  3026. public:
  3027. };
  3028. // CMapXVariables wrapper class
  3029. class CMapXVariables : public COleDispatchDriver
  3030. {
  3031. public:
  3032. CMapXVariables() {} // Calls COleDispatchDriver default constructor
  3033. CMapXVariables(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
  3034. CMapXVariables(const CMapXVariables& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
  3035. const CLSID& GetClsid() const
  3036. {
  3037. static bool bInitialized = false;
  3038. static CLSID clsid;
  3039. if(!bInitialized)
  3040. {
  3041. clsid = GetClassID(MAPX_PROGRAM_ID_PREFIX _T(".Variables.") MAPX_VERSION);
  3042. bInitialized = true;
  3043. }
  3044. return clsid;
  3045. }
  3046. // Attributes
  3047. public:
  3048. LPENUMVARIANT GetEnumerator();
  3049. long GetCount();
  3050. CMapXVariable operator[](long Index) { return Item(Index); }
  3051. CMapXVariable operator[](LPCTSTR Index) { return Item(Index); }
  3052. // Operations
  3053. public:
  3054. CMapXVariable Add(LPCTSTR Name, const VARIANT& Value);
  3055. CMapXVariable Add(LPCTSTR Name, long Value) 
  3056. { return Add(Name, COleVariant(Value)); }
  3057. CMapXVariable Add(LPCTSTR Name, short Value) 
  3058. { return Add(Name, COleVariant(Value)); }
  3059. CMapXVariable Add(LPCTSTR Name, double Value) 
  3060. { return Add(Name, COleVariant(Value)); }
  3061. CMapXVariable Add(LPCTSTR Name, LPCTSTR Value) 
  3062. { return Add(Name, COleVariant(Value)); }
  3063. CMapXVariable Item(const VARIANT& Index);
  3064. CMapXVariable Item(long Index) { return Item(COleVariant(Index)); }
  3065. CMapXVariable Item(LPCTSTR Index) { return Item(COleVariant(Index)); }
  3066. void Remove(const VARIANT& Index);
  3067. void Remove(long Index) { Remove(COleVariant(Index)); }
  3068. void Remove(LPCTSTR Index) { Remove(COleVariant(Index)); }
  3069. void RemoveAll();
  3070. CMapXVariables Clone();
  3071. };
  3072. #endif // __MAPX_H__/////////////////////////////////////////////////////////////////////////////