Category

Development Platform
Home > SourceCode/Document > Graph program > GIS program > View Code
moellipse.cpp
Package: MoLecture.rar　[view]
Upload User: qinfarui
Upload Date: 2022-08-10
Package Size: 362k
Code Size: 4k
Category:

GIS program

Development Platform:

Visual C++

moellipse.cpp：Code Content
  1. // Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
  3. // NOTE: Do not modify the contents of this file.  If this class is regenerated by
  4. //  Microsoft Visual C++, your modifications will be overwritten.
  7. #include "stdafx.h"
  8. #include "moellipse.h"
  10. // Dispatch interfaces referenced by this interface
  11. #include "MoRectangle.h"
  12. #include "MoPoint.h"
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CMoEllipse properties
  18. CMoRectangle CMoEllipse::GetExtent()
  19. {
  20. LPDISPATCH pDispatch;
  21. GetProperty(0x1, VT_DISPATCH, (void*)&pDispatch);
  22. return CMoRectangle(pDispatch);
  23. }
  25. void CMoEllipse::SetExtent(LPDISPATCH propVal)
  26. {
  27. SetProperty(0x1, VT_DISPATCH, propVal);
  28. }
  30. double CMoEllipse::GetLeft()
  31. {
  32. double result;
  33. GetProperty(0x2, VT_R8, (void*)&result);
  34. return result;
  35. }
  37. void CMoEllipse::SetLeft(double propVal)
  38. {
  39. SetProperty(0x2, VT_R8, propVal);
  40. }
  42. double CMoEllipse::GetRight()
  43. {
  44. double result;
  45. GetProperty(0x3, VT_R8, (void*)&result);
  46. return result;
  47. }
  49. void CMoEllipse::SetRight(double propVal)
  50. {
  51. SetProperty(0x3, VT_R8, propVal);
  52. }
  54. double CMoEllipse::GetTop()
  55. {
  56. double result;
  57. GetProperty(0x4, VT_R8, (void*)&result);
  58. return result;
  59. }
  61. void CMoEllipse::SetTop(double propVal)
  62. {
  63. SetProperty(0x4, VT_R8, propVal);
  64. }
  66. double CMoEllipse::GetBottom()
  67. {
  68. double result;
  69. GetProperty(0x5, VT_R8, (void*)&result);
  70. return result;
  71. }
  73. void CMoEllipse::SetBottom(double propVal)
  74. {
  75. SetProperty(0x5, VT_R8, propVal);
  76. }
  78. CMoPoint CMoEllipse::GetCenter()
  79. {
  80. LPDISPATCH pDispatch;
  81. GetProperty(0x6, VT_DISPATCH, (void*)&pDispatch);
  82. return CMoPoint(pDispatch);
  83. }
  85. void CMoEllipse::SetCenter(LPDISPATCH propVal)
  86. {
  87. SetProperty(0x6, VT_DISPATCH, propVal);
  88. }
  90. double CMoEllipse::GetWidth()
  91. {
  92. double result;
  93. GetProperty(0x7, VT_R8, (void*)&result);
  94. return result;
  95. }
  97. void CMoEllipse::SetWidth(double propVal)
  98. {
  99. SetProperty(0x7, VT_R8, propVal);
  100. }
  102. double CMoEllipse::GetHeight()
  103. {
  104. double result;
  105. GetProperty(0x8, VT_R8, (void*)&result);
  106. return result;
  107. }
  109. void CMoEllipse::SetHeight(double propVal)
  110. {
  111. SetProperty(0x8, VT_R8, propVal);
  112. }
  114. long CMoEllipse::GetShapeType()
  115. {
  116. long result;
  117. GetProperty(0x9, VT_I4, (void*)&result);
  118. return result;
  119. }
  121. void CMoEllipse::SetShapeType(long propVal)
  122. {
  123. SetProperty(0x9, VT_I4, propVal);
  124. }
  126. /////////////////////////////////////////////////////////////////////////////
  127. // CMoEllipse operations
  129. BOOL CMoEllipse::IsPointIn(LPDISPATCH Point)
  130. {
  131. BOOL result;
  132. static BYTE parms[] =
  133. VTS_DISPATCH;
  134. InvokeHelper(0xa, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  135. Point);
  136. return result;
  137. }
  139. void CMoEllipse::Offset(double deltaX, double deltaY)
  140. {
  141. static BYTE parms[] =
  142. VTS_R8 VTS_R8;
  143. InvokeHelper(0xb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  144.  deltaX, deltaY);
  145. }
  147. void CMoEllipse::Inset(double deltaX, double deltaY)
  148. {
  149. static BYTE parms[] =
  150. VTS_R8 VTS_R8;
  151. InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  152.  deltaX, deltaY);
  153. }
  155. LPDISPATCH CMoEllipse::Union(LPDISPATCH anotherShape, const VARIANT& Extent)
  156. {
  157. LPDISPATCH result;
  158. static BYTE parms[] =
  159. VTS_DISPATCH VTS_VARIANT;
  160. InvokeHelper(0xd, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  161. anotherShape, &Extent);
  162. return result;
  163. }
  165. LPDISPATCH CMoEllipse::Xor(LPDISPATCH anotherShape, const VARIANT& Extent)
  166. {
  167. LPDISPATCH result;
  168. static BYTE parms[] =
  169. VTS_DISPATCH VTS_VARIANT;
  170. InvokeHelper(0xe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  171. anotherShape, &Extent);
  172. return result;
  173. }
  175. LPDISPATCH CMoEllipse::Difference(LPDISPATCH anotherShape, const VARIANT& Extent)
  176. {
  177. LPDISPATCH result;
  178. static BYTE parms[] =
  179. VTS_DISPATCH VTS_VARIANT;
  180. InvokeHelper(0xf, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  181. anotherShape, &Extent);
  182. return result;
  183. }
  185. LPDISPATCH CMoEllipse::Intersect(LPDISPATCH anotherShape, const VARIANT& Extent)
  186. {
  187. LPDISPATCH result;
  188. static BYTE parms[] =
  189. VTS_DISPATCH VTS_VARIANT;
  190. InvokeHelper(0x10, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  191. anotherShape, &Extent);
  192. return result;
  193. }
  195. LPDISPATCH CMoEllipse::Buffer(double distance, const VARIANT& Extent)
  196. {
  197. LPDISPATCH result;
  198. static BYTE parms[] =
  199. VTS_R8 VTS_VARIANT;
  200. InvokeHelper(0x11, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  201. distance, &Extent);
  202. return result;
  203. }