excel9.cpp
上传用户:jzscgs158
上传日期:2022-05-25
资源大小:8709k
文件大小:157k
源码类别:

百货/超市行业

开发平台:

Visual C++

  1. return result;
  2. }
  3. void _Workbook::SetHasRoutingSlip(BOOL bNewValue)
  4. {
  5. static BYTE parms[] =
  6. VTS_BOOL;
  7. InvokeHelper(0x3b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  8.  bNewValue);
  9. }
  10. BOOL _Workbook::GetIsAddin()
  11. {
  12. BOOL result;
  13. InvokeHelper(0x5a5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  14. return result;
  15. }
  16. void _Workbook::SetIsAddin(BOOL bNewValue)
  17. {
  18. static BYTE parms[] =
  19. VTS_BOOL;
  20. InvokeHelper(0x5a5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  21.  bNewValue);
  22. }
  23. VARIANT _Workbook::LinkInfo(LPCTSTR Name, long LinkInfo, const VARIANT& Type, const VARIANT& EditionRef)
  24. {
  25. VARIANT result;
  26. static BYTE parms[] =
  27. VTS_BSTR VTS_I4 VTS_VARIANT VTS_VARIANT;
  28. InvokeHelper(0x327, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  29. Name, LinkInfo, &Type, &EditionRef);
  30. return result;
  31. }
  32. VARIANT _Workbook::LinkSources(const VARIANT& Type)
  33. {
  34. VARIANT result;
  35. static BYTE parms[] =
  36. VTS_VARIANT;
  37. InvokeHelper(0x328, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  38. &Type);
  39. return result;
  40. }
  41. LPDISPATCH _Workbook::GetMailer()
  42. {
  43. LPDISPATCH result;
  44. InvokeHelper(0x3d3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  45. return result;
  46. }
  47. void _Workbook::MergeWorkbook(const VARIANT& Filename)
  48. {
  49. static BYTE parms[] =
  50. VTS_VARIANT;
  51. InvokeHelper(0x5a6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  52.  &Filename);
  53. }
  54. BOOL _Workbook::GetMultiUserEditing()
  55. {
  56. BOOL result;
  57. InvokeHelper(0x491, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  58. return result;
  59. }
  60. CString _Workbook::GetName()
  61. {
  62. CString result;
  63. InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  64. return result;
  65. }
  66. LPDISPATCH _Workbook::GetNames()
  67. {
  68. LPDISPATCH result;
  69. InvokeHelper(0x1ba, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  70. return result;
  71. }
  72. LPDISPATCH _Workbook::NewWindow()
  73. {
  74. LPDISPATCH result;
  75. InvokeHelper(0x118, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  76. return result;
  77. }
  78. void _Workbook::OpenLinks(LPCTSTR Name, const VARIANT& ReadOnly, const VARIANT& Type)
  79. {
  80. static BYTE parms[] =
  81. VTS_BSTR VTS_VARIANT VTS_VARIANT;
  82. InvokeHelper(0x323, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  83.  Name, &ReadOnly, &Type);
  84. }
  85. CString _Workbook::GetPath()
  86. {
  87. CString result;
  88. InvokeHelper(0x123, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  89. return result;
  90. }
  91. BOOL _Workbook::GetPersonalViewListSettings()
  92. {
  93. BOOL result;
  94. InvokeHelper(0x5a7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  95. return result;
  96. }
  97. void _Workbook::SetPersonalViewListSettings(BOOL bNewValue)
  98. {
  99. static BYTE parms[] =
  100. VTS_BOOL;
  101. InvokeHelper(0x5a7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  102.  bNewValue);
  103. }
  104. BOOL _Workbook::GetPersonalViewPrintSettings()
  105. {
  106. BOOL result;
  107. InvokeHelper(0x5a8, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  108. return result;
  109. }
  110. void _Workbook::SetPersonalViewPrintSettings(BOOL bNewValue)
  111. {
  112. static BYTE parms[] =
  113. VTS_BOOL;
  114. InvokeHelper(0x5a8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  115.  bNewValue);
  116. }
  117. LPDISPATCH _Workbook::PivotCaches()
  118. {
  119. LPDISPATCH result;
  120. InvokeHelper(0x5a9, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, NULL);
  121. return result;
  122. }
  123. void _Workbook::Post(const VARIANT& DestName)
  124. {
  125. static BYTE parms[] =
  126. VTS_VARIANT;
  127. InvokeHelper(0x48e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  128.  &DestName);
  129. }
  130. BOOL _Workbook::GetPrecisionAsDisplayed()
  131. {
  132. BOOL result;
  133. InvokeHelper(0x195, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  134. return result;
  135. }
  136. void _Workbook::SetPrecisionAsDisplayed(BOOL bNewValue)
  137. {
  138. static BYTE parms[] =
  139. VTS_BOOL;
  140. InvokeHelper(0x195, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  141.  bNewValue);
  142. }
  143. void _Workbook::PrintPreview(const VARIANT& EnableChanges)
  144. {
  145. static BYTE parms[] =
  146. VTS_VARIANT;
  147. InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  148.  &EnableChanges);
  149. }
  150. void _Workbook::Protect(const VARIANT& Password, const VARIANT& Structure, const VARIANT& Windows)
  151. {
  152. static BYTE parms[] =
  153. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  154. InvokeHelper(0x11a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  155.  &Password, &Structure, &Windows);
  156. }
  157. void _Workbook::ProtectSharing(const VARIANT& Filename, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, const VARIANT& SharingPassword)
  158. {
  159. static BYTE parms[] =
  160. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  161. InvokeHelper(0x5aa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  162.  &Filename, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, &SharingPassword);
  163. }
  164. BOOL _Workbook::GetProtectStructure()
  165. {
  166. BOOL result;
  167. InvokeHelper(0x24c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  168. return result;
  169. }
  170. BOOL _Workbook::GetProtectWindows()
  171. {
  172. BOOL result;
  173. InvokeHelper(0x127, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  174. return result;
  175. }
  176. BOOL _Workbook::GetReadOnly()
  177. {
  178. BOOL result;
  179. InvokeHelper(0x128, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  180. return result;
  181. }
  182. BOOL _Workbook::GetReadOnlyRecommended()
  183. {
  184. BOOL result;
  185. InvokeHelper(0x129, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  186. return result;
  187. }
  188. void _Workbook::RefreshAll()
  189. {
  190. InvokeHelper(0x5ac, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  191. }
  192. void _Workbook::Reply()
  193. {
  194. InvokeHelper(0x3d1, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  195. }
  196. void _Workbook::ReplyAll()
  197. {
  198. InvokeHelper(0x3d2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  199. }
  200. void _Workbook::RemoveUser(long Index)
  201. {
  202. static BYTE parms[] =
  203. VTS_I4;
  204. InvokeHelper(0x5ad, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  205.  Index);
  206. }
  207. long _Workbook::GetRevisionNumber()
  208. {
  209. long result;
  210. InvokeHelper(0x494, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  211. return result;
  212. }
  213. void _Workbook::Route()
  214. {
  215. InvokeHelper(0x3b2, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  216. }
  217. BOOL _Workbook::GetRouted()
  218. {
  219. BOOL result;
  220. InvokeHelper(0x3b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  221. return result;
  222. }
  223. LPDISPATCH _Workbook::GetRoutingSlip()
  224. {
  225. LPDISPATCH result;
  226. InvokeHelper(0x3b5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  227. return result;
  228. }
  229. void _Workbook::RunAutoMacros(long Which)
  230. {
  231. static BYTE parms[] =
  232. VTS_I4;
  233. InvokeHelper(0x27a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  234.  Which);
  235. }
  236. void _Workbook::Save()
  237. {
  238. InvokeHelper(0x11b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  239. }
  240. void _Workbook::SaveAs(const VARIANT& Filename, const VARIANT& FileFormat, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& ReadOnlyRecommended, const VARIANT& CreateBackup, long AccessMode, const VARIANT& ConflictResolution,  const VARIANT& AddToMru, const VARIANT& TextCodepage, const VARIANT& TextVisualLayout)
  241. {
  242. static BYTE parms[] =
  243. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  244. InvokeHelper(0x11c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  245.  &Filename, &FileFormat, &Password, &WriteResPassword, &ReadOnlyRecommended, &CreateBackup, AccessMode, &ConflictResolution, &AddToMru, &TextCodepage, &TextVisualLayout);
  246. }
  247. void _Workbook::SaveCopyAs(const VARIANT& Filename)
  248. {
  249. static BYTE parms[] =
  250. VTS_VARIANT;
  251. InvokeHelper(0xaf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  252.  &Filename);
  253. }
  254. BOOL _Workbook::GetSaved()
  255. {
  256. BOOL result;
  257. InvokeHelper(0x12a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  258. return result;
  259. }
  260. void _Workbook::SetSaved(BOOL bNewValue)
  261. {
  262. static BYTE parms[] =
  263. VTS_BOOL;
  264. InvokeHelper(0x12a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  265.  bNewValue);
  266. }
  267. BOOL _Workbook::GetSaveLinkValues()
  268. {
  269. BOOL result;
  270. InvokeHelper(0x196, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  271. return result;
  272. }
  273. void _Workbook::SetSaveLinkValues(BOOL bNewValue)
  274. {
  275. static BYTE parms[] =
  276. VTS_BOOL;
  277. InvokeHelper(0x196, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  278.  bNewValue);
  279. }
  280. void _Workbook::SendMail(const VARIANT& Recipients, const VARIANT& Subject, const VARIANT& ReturnReceipt)
  281. {
  282. static BYTE parms[] =
  283. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  284. InvokeHelper(0x3b3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  285.  &Recipients, &Subject, &ReturnReceipt);
  286. }
  287. void _Workbook::SendMailer(const VARIANT& FileFormat, long Priority)
  288. {
  289. static BYTE parms[] =
  290. VTS_VARIANT VTS_I4;
  291. InvokeHelper(0x3d4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  292.  &FileFormat, Priority);
  293. }
  294. void _Workbook::SetLinkOnData(LPCTSTR Name, const VARIANT& Procedure)
  295. {
  296. static BYTE parms[] =
  297. VTS_BSTR VTS_VARIANT;
  298. InvokeHelper(0x329, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  299.  Name, &Procedure);
  300. }
  301. LPDISPATCH _Workbook::GetSheets()
  302. {
  303. LPDISPATCH result;
  304. InvokeHelper(0x1e5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  305. return result;
  306. }
  307. BOOL _Workbook::GetShowConflictHistory()
  308. {
  309. BOOL result;
  310. InvokeHelper(0x493, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  311. return result;
  312. }
  313. void _Workbook::SetShowConflictHistory(BOOL bNewValue)
  314. {
  315. static BYTE parms[] =
  316. VTS_BOOL;
  317. InvokeHelper(0x493, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  318.  bNewValue);
  319. }
  320. LPDISPATCH _Workbook::GetStyles()
  321. {
  322. LPDISPATCH result;
  323. InvokeHelper(0x1ed, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  324. return result;
  325. }
  326. void _Workbook::Unprotect(const VARIANT& Password)
  327. {
  328. static BYTE parms[] =
  329. VTS_VARIANT;
  330. InvokeHelper(0x11d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  331.  &Password);
  332. }
  333. void _Workbook::UnprotectSharing(const VARIANT& SharingPassword)
  334. {
  335. static BYTE parms[] =
  336. VTS_VARIANT;
  337. InvokeHelper(0x5af, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  338.  &SharingPassword);
  339. }
  340. void _Workbook::UpdateFromFile()
  341. {
  342. InvokeHelper(0x3e3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  343. }
  344. void _Workbook::UpdateLink(const VARIANT& Name, const VARIANT& Type)
  345. {
  346. static BYTE parms[] =
  347. VTS_VARIANT VTS_VARIANT;
  348. InvokeHelper(0x324, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  349.  &Name, &Type);
  350. }
  351. BOOL _Workbook::GetUpdateRemoteReferences()
  352. {
  353. BOOL result;
  354. InvokeHelper(0x19b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  355. return result;
  356. }
  357. void _Workbook::SetUpdateRemoteReferences(BOOL bNewValue)
  358. {
  359. static BYTE parms[] =
  360. VTS_BOOL;
  361. InvokeHelper(0x19b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  362.  bNewValue);
  363. }
  364. VARIANT _Workbook::GetUserStatus()
  365. {
  366. VARIANT result;
  367. InvokeHelper(0x495, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  368. return result;
  369. }
  370. LPDISPATCH _Workbook::GetCustomViews()
  371. {
  372. LPDISPATCH result;
  373. InvokeHelper(0x5b0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  374. return result;
  375. }
  376. LPDISPATCH _Workbook::GetWindows()
  377. {
  378. LPDISPATCH result;
  379. InvokeHelper(0x1ae, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  380. return result;
  381. }
  382. LPDISPATCH _Workbook::GetWorksheets()
  383. {
  384. LPDISPATCH result;
  385. InvokeHelper(0x1ee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  386. return result;
  387. }
  388. BOOL _Workbook::GetWriteReserved()
  389. {
  390. BOOL result;
  391. InvokeHelper(0x12b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  392. return result;
  393. }
  394. CString _Workbook::GetWriteReservedBy()
  395. {
  396. CString result;
  397. InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  398. return result;
  399. }
  400. LPDISPATCH _Workbook::GetExcel4IntlMacroSheets()
  401. {
  402. LPDISPATCH result;
  403. InvokeHelper(0x245, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  404. return result;
  405. }
  406. LPDISPATCH _Workbook::GetExcel4MacroSheets()
  407. {
  408. LPDISPATCH result;
  409. InvokeHelper(0x243, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  410. return result;
  411. }
  412. BOOL _Workbook::GetTemplateRemoveExtData()
  413. {
  414. BOOL result;
  415. InvokeHelper(0x5b1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  416. return result;
  417. }
  418. void _Workbook::SetTemplateRemoveExtData(BOOL bNewValue)
  419. {
  420. static BYTE parms[] =
  421. VTS_BOOL;
  422. InvokeHelper(0x5b1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  423.  bNewValue);
  424. }
  425. void _Workbook::HighlightChangesOptions(const VARIANT& When, const VARIANT& Who, const VARIANT& Where)
  426. {
  427. static BYTE parms[] =
  428. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  429. InvokeHelper(0x5b2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  430.  &When, &Who, &Where);
  431. }
  432. BOOL _Workbook::GetHighlightChangesOnScreen()
  433. {
  434. BOOL result;
  435. InvokeHelper(0x5b5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  436. return result;
  437. }
  438. void _Workbook::SetHighlightChangesOnScreen(BOOL bNewValue)
  439. {
  440. static BYTE parms[] =
  441. VTS_BOOL;
  442. InvokeHelper(0x5b5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  443.  bNewValue);
  444. }
  445. BOOL _Workbook::GetKeepChangeHistory()
  446. {
  447. BOOL result;
  448. InvokeHelper(0x5b6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  449. return result;
  450. }
  451. void _Workbook::SetKeepChangeHistory(BOOL bNewValue)
  452. {
  453. static BYTE parms[] =
  454. VTS_BOOL;
  455. InvokeHelper(0x5b6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  456.  bNewValue);
  457. }
  458. BOOL _Workbook::GetListChangesOnNewSheet()
  459. {
  460. BOOL result;
  461. InvokeHelper(0x5b7, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  462. return result;
  463. }
  464. void _Workbook::SetListChangesOnNewSheet(BOOL bNewValue)
  465. {
  466. static BYTE parms[] =
  467. VTS_BOOL;
  468. InvokeHelper(0x5b7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  469.  bNewValue);
  470. }
  471. void _Workbook::PurgeChangeHistoryNow(long Days, const VARIANT& SharingPassword)
  472. {
  473. static BYTE parms[] =
  474. VTS_I4 VTS_VARIANT;
  475. InvokeHelper(0x5b8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  476.  Days, &SharingPassword);
  477. }
  478. void _Workbook::AcceptAllChanges(const VARIANT& When, const VARIANT& Who, const VARIANT& Where)
  479. {
  480. static BYTE parms[] =
  481. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  482. InvokeHelper(0x5ba, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  483.  &When, &Who, &Where);
  484. }
  485. void _Workbook::RejectAllChanges(const VARIANT& When, const VARIANT& Who, const VARIANT& Where)
  486. {
  487. static BYTE parms[] =
  488. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  489. InvokeHelper(0x5bb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  490.  &When, &Who, &Where);
  491. }
  492. void _Workbook::ResetColors()
  493. {
  494. InvokeHelper(0x5bc, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  495. }
  496. LPDISPATCH _Workbook::GetVBProject()
  497. {
  498. LPDISPATCH result;
  499. InvokeHelper(0x5bd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  500. return result;
  501. }
  502. void _Workbook::FollowHyperlink(LPCTSTR Address, const VARIANT& SubAddress, const VARIANT& NewWindow, const VARIANT& AddHistory, const VARIANT& ExtraInfo, const VARIANT& Method, const VARIANT& HeaderInfo)
  503. {
  504. static BYTE parms[] =
  505. VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  506. InvokeHelper(0x5be, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  507.  Address, &SubAddress, &NewWindow, &AddHistory, &ExtraInfo, &Method, &HeaderInfo);
  508. }
  509. void _Workbook::AddToFavorites()
  510. {
  511. InvokeHelper(0x5c4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  512. }
  513. BOOL _Workbook::GetIsInplace()
  514. {
  515. BOOL result;
  516. InvokeHelper(0x6e9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  517. return result;
  518. }
  519. void _Workbook::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName)
  520. {
  521. static BYTE parms[] =
  522. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  523. InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  524.  &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName);
  525. }
  526. void _Workbook::WebPagePreview()
  527. {
  528. InvokeHelper(0x71a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  529. }
  530. LPDISPATCH _Workbook::GetPublishObjects()
  531. {
  532. LPDISPATCH result;
  533. InvokeHelper(0x71b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  534. return result;
  535. }
  536. LPDISPATCH _Workbook::GetWebOptions()
  537. {
  538. LPDISPATCH result;
  539. InvokeHelper(0x71c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  540. return result;
  541. }
  542. void _Workbook::ReloadAs(long Encoding)
  543. {
  544. static BYTE parms[] =
  545. VTS_I4;
  546. InvokeHelper(0x71d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  547.  Encoding);
  548. }
  549. LPDISPATCH _Workbook::GetHTMLProject()
  550. {
  551. LPDISPATCH result;
  552. InvokeHelper(0x71f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  553. return result;
  554. }
  555. BOOL _Workbook::GetEnvelopeVisible()
  556. {
  557. BOOL result;
  558. InvokeHelper(0x720, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  559. return result;
  560. }
  561. void _Workbook::SetEnvelopeVisible(BOOL bNewValue)
  562. {
  563. static BYTE parms[] =
  564. VTS_BOOL;
  565. InvokeHelper(0x720, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  566.  bNewValue);
  567. }
  568. long _Workbook::GetCalculationVersion()
  569. {
  570. long result;
  571. InvokeHelper(0x70e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  572. return result;
  573. }
  574. BOOL _Workbook::GetVBASigned()
  575. {
  576. BOOL result;
  577. InvokeHelper(0x724, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  578. return result;
  579. }
  580. /////////////////////////////////////////////////////////////////////////////
  581. // Workbooks properties
  582. /////////////////////////////////////////////////////////////////////////////
  583. // Workbooks operations
  584. LPDISPATCH Workbooks::GetApplication()
  585. {
  586. LPDISPATCH result;
  587. InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  588. return result;
  589. }
  590. long Workbooks::GetCreator()
  591. {
  592. long result;
  593. InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  594. return result;
  595. }
  596. LPDISPATCH Workbooks::GetParent()
  597. {
  598. LPDISPATCH result;
  599. InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  600. return result;
  601. }
  602. LPDISPATCH Workbooks::Add(const VARIANT& Template)
  603. {
  604. LPDISPATCH result;
  605. static BYTE parms[] =
  606. VTS_VARIANT;
  607. InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  608. &Template);
  609. return result;
  610. }
  611. void Workbooks::Close()
  612. {
  613. InvokeHelper(0x115, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  614. }
  615. long Workbooks::GetCount()
  616. {
  617. long result;
  618. InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  619. return result;
  620. }
  621. LPDISPATCH Workbooks::GetItem(const VARIANT& Index)
  622. {
  623. LPDISPATCH result;
  624. static BYTE parms[] =
  625. VTS_VARIANT;
  626. InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  627. &Index);
  628. return result;
  629. }
  630. LPUNKNOWN Workbooks::Get_NewEnum()
  631. {
  632. LPUNKNOWN result;
  633. InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
  634. return result;
  635. }
  636. LPDISPATCH Workbooks::Open(LPCTSTR Filename, const VARIANT& UpdateLinks, const VARIANT& ReadOnly, const VARIANT& Format, const VARIANT& Password, const VARIANT& WriteResPassword, const VARIANT& IgnoreReadOnlyRecommended, const VARIANT& Origin,  const VARIANT& Delimiter, const VARIANT& Editable, const VARIANT& Notify, const VARIANT& Converter, const VARIANT& AddToMru)
  637. {
  638. LPDISPATCH result;
  639. static BYTE parms[] =
  640. VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  641. InvokeHelper(0x2aa, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  642. Filename, &UpdateLinks, &ReadOnly, &Format, &Password, &WriteResPassword, &IgnoreReadOnlyRecommended, &Origin, &Delimiter, &Editable, &Notify, &Converter, &AddToMru);
  643. return result;
  644. }
  645. LPDISPATCH Workbooks::Get_Default(const VARIANT& Index)
  646. {
  647. LPDISPATCH result;
  648. static BYTE parms[] =
  649. VTS_VARIANT;
  650. InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  651. &Index);
  652. return result;
  653. }
  654. void Workbooks::OpenText(LPCTSTR Filename, const VARIANT& Origin, const VARIANT& StartRow, const VARIANT& DataType, long TextQualifier, const VARIANT& ConsecutiveDelimiter, const VARIANT& Tab, const VARIANT& Semicolon, const VARIANT& Comma,  const VARIANT& Space, const VARIANT& Other, const VARIANT& OtherChar, const VARIANT& FieldInfo, const VARIANT& TextVisualLayout, const VARIANT& DecimalSeparator, const VARIANT& ThousandsSeparator)
  655. {
  656. static BYTE parms[] =
  657. VTS_BSTR VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  658. InvokeHelper(0x6ed, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  659.  Filename, &Origin, &StartRow, &DataType, TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo, &TextVisualLayout, &DecimalSeparator, &ThousandsSeparator);
  660. }
  661. /////////////////////////////////////////////////////////////////////////////
  662. // Font properties
  663. /////////////////////////////////////////////////////////////////////////////
  664. // Font operations
  665. LPDISPATCH Font::GetApplication()
  666. {
  667. LPDISPATCH result;
  668. InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  669. return result;
  670. }
  671. long Font::GetCreator()
  672. {
  673. long result;
  674. InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  675. return result;
  676. }
  677. LPDISPATCH Font::GetParent()
  678. {
  679. LPDISPATCH result;
  680. InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  681. return result;
  682. }
  683. VARIANT Font::GetBackground()
  684. {
  685. VARIANT result;
  686. InvokeHelper(0xb4, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  687. return result;
  688. }
  689. void Font::SetBackground(const VARIANT& newValue)
  690. {
  691. static BYTE parms[] =
  692. VTS_VARIANT;
  693. InvokeHelper(0xb4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  694.  &newValue);
  695. }
  696. VARIANT Font::GetBold()
  697. {
  698. VARIANT result;
  699. InvokeHelper(0x60, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  700. return result;
  701. }
  702. void Font::SetBold(const VARIANT& newValue)
  703. {
  704. static BYTE parms[] =
  705. VTS_VARIANT;
  706. InvokeHelper(0x60, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  707.  &newValue);
  708. }
  709. VARIANT Font::GetColor()
  710. {
  711. VARIANT result;
  712. InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  713. return result;
  714. }
  715. void Font::SetColor(const VARIANT& newValue)
  716. {
  717. static BYTE parms[] =
  718. VTS_VARIANT;
  719. InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  720.  &newValue);
  721. }
  722. VARIANT Font::GetColorIndex()
  723. {
  724. VARIANT result;
  725. InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  726. return result;
  727. }
  728. void Font::SetColorIndex(const VARIANT& newValue)
  729. {
  730. static BYTE parms[] =
  731. VTS_VARIANT;
  732. InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  733.  &newValue);
  734. }
  735. VARIANT Font::GetFontStyle()
  736. {
  737. VARIANT result;
  738. InvokeHelper(0xb1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  739. return result;
  740. }
  741. void Font::SetFontStyle(const VARIANT& newValue)
  742. {
  743. static BYTE parms[] =
  744. VTS_VARIANT;
  745. InvokeHelper(0xb1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  746.  &newValue);
  747. }
  748. VARIANT Font::GetItalic()
  749. {
  750. VARIANT result;
  751. InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  752. return result;
  753. }
  754. void Font::SetItalic(const VARIANT& newValue)
  755. {
  756. static BYTE parms[] =
  757. VTS_VARIANT;
  758. InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  759.  &newValue);
  760. }
  761. VARIANT Font::GetName()
  762. {
  763. VARIANT result;
  764. InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  765. return result;
  766. }
  767. void Font::SetName(const VARIANT& newValue)
  768. {
  769. static BYTE parms[] =
  770. VTS_VARIANT;
  771. InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  772.  &newValue);
  773. }
  774. VARIANT Font::GetOutlineFont()
  775. {
  776. VARIANT result;
  777. InvokeHelper(0xdd, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  778. return result;
  779. }
  780. void Font::SetOutlineFont(const VARIANT& newValue)
  781. {
  782. static BYTE parms[] =
  783. VTS_VARIANT;
  784. InvokeHelper(0xdd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  785.  &newValue);
  786. }
  787. VARIANT Font::GetShadow()
  788. {
  789. VARIANT result;
  790. InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  791. return result;
  792. }
  793. void Font::SetShadow(const VARIANT& newValue)
  794. {
  795. static BYTE parms[] =
  796. VTS_VARIANT;
  797. InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  798.  &newValue);
  799. }
  800. VARIANT Font::GetSize()
  801. {
  802. VARIANT result;
  803. InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  804. return result;
  805. }
  806. void Font::SetSize(const VARIANT& newValue)
  807. {
  808. static BYTE parms[] =
  809. VTS_VARIANT;
  810. InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  811.  &newValue);
  812. }
  813. VARIANT Font::GetStrikethrough()
  814. {
  815. VARIANT result;
  816. InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  817. return result;
  818. }
  819. void Font::SetStrikethrough(const VARIANT& newValue)
  820. {
  821. static BYTE parms[] =
  822. VTS_VARIANT;
  823. InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  824.  &newValue);
  825. }
  826. VARIANT Font::GetSubscript()
  827. {
  828. VARIANT result;
  829. InvokeHelper(0xb3, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  830. return result;
  831. }
  832. void Font::SetSubscript(const VARIANT& newValue)
  833. {
  834. static BYTE parms[] =
  835. VTS_VARIANT;
  836. InvokeHelper(0xb3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  837.  &newValue);
  838. }
  839. VARIANT Font::GetSuperscript()
  840. {
  841. VARIANT result;
  842. InvokeHelper(0xb2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  843. return result;
  844. }
  845. void Font::SetSuperscript(const VARIANT& newValue)
  846. {
  847. static BYTE parms[] =
  848. VTS_VARIANT;
  849. InvokeHelper(0xb2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  850.  &newValue);
  851. }
  852. VARIANT Font::GetUnderline()
  853. {
  854. VARIANT result;
  855. InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  856. return result;
  857. }
  858. void Font::SetUnderline(const VARIANT& newValue)
  859. {
  860. static BYTE parms[] =
  861. VTS_VARIANT;
  862. InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  863.  &newValue);
  864. }
  865. /////////////////////////////////////////////////////////////////////////////
  866. // Range properties
  867. /////////////////////////////////////////////////////////////////////////////
  868. // Range operations
  869. LPDISPATCH Range::GetApplication()
  870. {
  871. LPDISPATCH result;
  872. InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  873. return result;
  874. }
  875. long Range::GetCreator()
  876. {
  877. long result;
  878. InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  879. return result;
  880. }
  881. LPDISPATCH Range::GetParent()
  882. {
  883. LPDISPATCH result;
  884. InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  885. return result;
  886. }
  887. VARIANT Range::Activate()
  888. {
  889. VARIANT result;
  890. InvokeHelper(0x130, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  891. return result;
  892. }
  893. VARIANT Range::GetAddIndent()
  894. {
  895. VARIANT result;
  896. InvokeHelper(0x427, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  897. return result;
  898. }
  899. void Range::SetAddIndent(const VARIANT& newValue)
  900. {
  901. static BYTE parms[] =
  902. VTS_VARIANT;
  903. InvokeHelper(0x427, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  904.  &newValue);
  905. }
  906. CString Range::GetAddress(const VARIANT& RowAbsolute, const VARIANT& ColumnAbsolute, long ReferenceStyle, const VARIANT& External, const VARIANT& RelativeTo)
  907. {
  908. CString result;
  909. static BYTE parms[] =
  910. VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT;
  911. InvokeHelper(0xec, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  912. &RowAbsolute, &ColumnAbsolute, ReferenceStyle, &External, &RelativeTo);
  913. return result;
  914. }
  915. CString Range::GetAddressLocal(const VARIANT& RowAbsolute, const VARIANT& ColumnAbsolute, long ReferenceStyle, const VARIANT& External, const VARIANT& RelativeTo)
  916. {
  917. CString result;
  918. static BYTE parms[] =
  919. VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT;
  920. InvokeHelper(0x1b5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  921. &RowAbsolute, &ColumnAbsolute, ReferenceStyle, &External, &RelativeTo);
  922. return result;
  923. }
  924. VARIANT Range::AdvancedFilter(long Action, const VARIANT& CriteriaRange, const VARIANT& CopyToRange, const VARIANT& Unique)
  925. {
  926. VARIANT result;
  927. static BYTE parms[] =
  928. VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  929. InvokeHelper(0x36c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  930. Action, &CriteriaRange, &CopyToRange, &Unique);
  931. return result;
  932. }
  933. VARIANT Range::ApplyNames(const VARIANT& Names, const VARIANT& IgnoreRelativeAbsolute, const VARIANT& UseRowColumnNames, const VARIANT& OmitColumn, const VARIANT& OmitRow, long Order, const VARIANT& AppendLast)
  934. {
  935. VARIANT result;
  936. static BYTE parms[] =
  937. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT;
  938. InvokeHelper(0x1b9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  939. &Names, &IgnoreRelativeAbsolute, &UseRowColumnNames, &OmitColumn, &OmitRow, Order, &AppendLast);
  940. return result;
  941. }
  942. VARIANT Range::ApplyOutlineStyles()
  943. {
  944. VARIANT result;
  945. InvokeHelper(0x1c0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  946. return result;
  947. }
  948. LPDISPATCH Range::GetAreas()
  949. {
  950. LPDISPATCH result;
  951. InvokeHelper(0x238, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  952. return result;
  953. }
  954. CString Range::AutoComplete(LPCTSTR String)
  955. {
  956. CString result;
  957. static BYTE parms[] =
  958. VTS_BSTR;
  959. InvokeHelper(0x4a1, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  960. String);
  961. return result;
  962. }
  963. VARIANT Range::AutoFill(LPDISPATCH Destination, long Type)
  964. {
  965. VARIANT result;
  966. static BYTE parms[] =
  967. VTS_DISPATCH VTS_I4;
  968. InvokeHelper(0x1c1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  969. Destination, Type);
  970. return result;
  971. }
  972. VARIANT Range::AutoFilter(const VARIANT& Field, const VARIANT& Criteria1, long Operator, const VARIANT& Criteria2, const VARIANT& VisibleDropDown)
  973. {
  974. VARIANT result;
  975. static BYTE parms[] =
  976. VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT;
  977. InvokeHelper(0x319, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  978. &Field, &Criteria1, Operator, &Criteria2, &VisibleDropDown);
  979. return result;
  980. }
  981. VARIANT Range::AutoFit()
  982. {
  983. VARIANT result;
  984. InvokeHelper(0xed, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  985. return result;
  986. }
  987. VARIANT Range::AutoFormat(long Format, const VARIANT& Number, const VARIANT& Font, const VARIANT& Alignment, const VARIANT& Border, const VARIANT& Pattern, const VARIANT& Width)
  988. {
  989. VARIANT result;
  990. static BYTE parms[] =
  991. VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  992. InvokeHelper(0x72, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  993. Format, &Number, &Font, &Alignment, &Border, &Pattern, &Width);
  994. return result;
  995. }
  996. VARIANT Range::AutoOutline()
  997. {
  998. VARIANT result;
  999. InvokeHelper(0x40c, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1000. return result;
  1001. }
  1002. VARIANT Range::BorderAround(const VARIANT& LineStyle, long Weight, long ColorIndex, const VARIANT& Color)
  1003. {
  1004. VARIANT result;
  1005. static BYTE parms[] =
  1006. VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT;
  1007. InvokeHelper(0x42b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1008. &LineStyle, Weight, ColorIndex, &Color);
  1009. return result;
  1010. }
  1011. LPDISPATCH Range::GetBorders()
  1012. {
  1013. LPDISPATCH result;
  1014. InvokeHelper(0x1b3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1015. return result;
  1016. }
  1017. VARIANT Range::Calculate()
  1018. {
  1019. VARIANT result;
  1020. InvokeHelper(0x117, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1021. return result;
  1022. }
  1023. LPDISPATCH Range::GetCells()
  1024. {
  1025. LPDISPATCH result;
  1026. InvokeHelper(0xee, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1027. return result;
  1028. }
  1029. LPDISPATCH Range::GetCharacters(const VARIANT& Start, const VARIANT& Length)
  1030. {
  1031. LPDISPATCH result;
  1032. static BYTE parms[] =
  1033. VTS_VARIANT VTS_VARIANT;
  1034. InvokeHelper(0x25b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  1035. &Start, &Length);
  1036. return result;
  1037. }
  1038. VARIANT Range::CheckSpelling(const VARIANT& CustomDictionary, const VARIANT& IgnoreUppercase, const VARIANT& AlwaysSuggest, const VARIANT& SpellLang)
  1039. {
  1040. VARIANT result;
  1041. static BYTE parms[] =
  1042. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1043. InvokeHelper(0x1f9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1044. &CustomDictionary, &IgnoreUppercase, &AlwaysSuggest, &SpellLang);
  1045. return result;
  1046. }
  1047. VARIANT Range::Clear()
  1048. {
  1049. VARIANT result;
  1050. InvokeHelper(0x6f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1051. return result;
  1052. }
  1053. VARIANT Range::ClearContents()
  1054. {
  1055. VARIANT result;
  1056. InvokeHelper(0x71, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1057. return result;
  1058. }
  1059. VARIANT Range::ClearFormats()
  1060. {
  1061. VARIANT result;
  1062. InvokeHelper(0x70, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1063. return result;
  1064. }
  1065. VARIANT Range::ClearNotes()
  1066. {
  1067. VARIANT result;
  1068. InvokeHelper(0xef, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1069. return result;
  1070. }
  1071. VARIANT Range::ClearOutline()
  1072. {
  1073. VARIANT result;
  1074. InvokeHelper(0x40d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1075. return result;
  1076. }
  1077. long Range::GetColumn()
  1078. {
  1079. long result;
  1080. InvokeHelper(0xf0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  1081. return result;
  1082. }
  1083. LPDISPATCH Range::ColumnDifferences(const VARIANT& Comparison)
  1084. {
  1085. LPDISPATCH result;
  1086. static BYTE parms[] =
  1087. VTS_VARIANT;
  1088. InvokeHelper(0x1fe, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1089. &Comparison);
  1090. return result;
  1091. }
  1092. LPDISPATCH Range::GetColumns()
  1093. {
  1094. LPDISPATCH result;
  1095. InvokeHelper(0xf1, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1096. return result;
  1097. }
  1098. VARIANT Range::GetColumnWidth()
  1099. {
  1100. VARIANT result;
  1101. InvokeHelper(0xf2, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1102. return result;
  1103. }
  1104. void Range::SetColumnWidth(const VARIANT& newValue)
  1105. {
  1106. static BYTE parms[] =
  1107. VTS_VARIANT;
  1108. InvokeHelper(0xf2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1109.  &newValue);
  1110. }
  1111. VARIANT Range::Consolidate(const VARIANT& Sources, const VARIANT& Function, const VARIANT& TopRow, const VARIANT& LeftColumn, const VARIANT& CreateLinks)
  1112. {
  1113. VARIANT result;
  1114. static BYTE parms[] =
  1115. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1116. InvokeHelper(0x1e2, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1117. &Sources, &Function, &TopRow, &LeftColumn, &CreateLinks);
  1118. return result;
  1119. }
  1120. VARIANT Range::Copy(const VARIANT& Destination)
  1121. {
  1122. VARIANT result;
  1123. static BYTE parms[] =
  1124. VTS_VARIANT;
  1125. InvokeHelper(0x227, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1126. &Destination);
  1127. return result;
  1128. }
  1129. long Range::CopyFromRecordset(LPUNKNOWN Data, const VARIANT& MaxRows, const VARIANT& MaxColumns)
  1130. {
  1131. long result;
  1132. static BYTE parms[] =
  1133. VTS_UNKNOWN VTS_VARIANT VTS_VARIANT;
  1134. InvokeHelper(0x480, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
  1135. Data, &MaxRows, &MaxColumns);
  1136. return result;
  1137. }
  1138. VARIANT Range::CopyPicture(long Appearance, long Format)
  1139. {
  1140. VARIANT result;
  1141. static BYTE parms[] =
  1142. VTS_I4 VTS_I4;
  1143. InvokeHelper(0xd5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1144. Appearance, Format);
  1145. return result;
  1146. }
  1147. long Range::GetCount()
  1148. {
  1149. long result;
  1150. InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  1151. return result;
  1152. }
  1153. VARIANT Range::CreateNames(const VARIANT& Top, const VARIANT& Left, const VARIANT& Bottom, const VARIANT& Right)
  1154. {
  1155. VARIANT result;
  1156. static BYTE parms[] =
  1157. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1158. InvokeHelper(0x1c9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1159. &Top, &Left, &Bottom, &Right);
  1160. return result;
  1161. }
  1162. VARIANT Range::CreatePublisher(const VARIANT& Edition, long Appearance, const VARIANT& ContainsPICT, const VARIANT& ContainsBIFF, const VARIANT& ContainsRTF, const VARIANT& ContainsVALU)
  1163. {
  1164. VARIANT result;
  1165. static BYTE parms[] =
  1166. VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1167. InvokeHelper(0x1ca, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1168. &Edition, Appearance, &ContainsPICT, &ContainsBIFF, &ContainsRTF, &ContainsVALU);
  1169. return result;
  1170. }
  1171. LPDISPATCH Range::GetCurrentArray()
  1172. {
  1173. LPDISPATCH result;
  1174. InvokeHelper(0x1f5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1175. return result;
  1176. }
  1177. LPDISPATCH Range::GetCurrentRegion()
  1178. {
  1179. LPDISPATCH result;
  1180. InvokeHelper(0xf3, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1181. return result;
  1182. }
  1183. VARIANT Range::Cut(const VARIANT& Destination)
  1184. {
  1185. VARIANT result;
  1186. static BYTE parms[] =
  1187. VTS_VARIANT;
  1188. InvokeHelper(0x235, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1189. &Destination);
  1190. return result;
  1191. }
  1192. VARIANT Range::DataSeries(const VARIANT& Rowcol, long Type, long Date, const VARIANT& Step, const VARIANT& Stop, const VARIANT& Trend)
  1193. {
  1194. VARIANT result;
  1195. static BYTE parms[] =
  1196. VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1197. InvokeHelper(0x1d0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1198. &Rowcol, Type, Date, &Step, &Stop, &Trend);
  1199. return result;
  1200. }
  1201. VARIANT Range::Get_Default(const VARIANT& RowIndex, const VARIANT& ColumnIndex)
  1202. {
  1203. VARIANT result;
  1204. static BYTE parms[] =
  1205. VTS_VARIANT VTS_VARIANT;
  1206. InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
  1207. &RowIndex, &ColumnIndex);
  1208. return result;
  1209. }
  1210. void Range::Set_Default(const VARIANT& RowIndex, const VARIANT& ColumnIndex, const VARIANT& newValue)
  1211. {
  1212. static BYTE parms[] =
  1213. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1214. InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1215.  &RowIndex, &ColumnIndex, &newValue);
  1216. }
  1217. VARIANT Range::Delete(const VARIANT& Shift)
  1218. {
  1219. VARIANT result;
  1220. static BYTE parms[] =
  1221. VTS_VARIANT;
  1222. InvokeHelper(0x75, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1223. &Shift);
  1224. return result;
  1225. }
  1226. LPDISPATCH Range::GetDependents()
  1227. {
  1228. LPDISPATCH result;
  1229. InvokeHelper(0x21f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1230. return result;
  1231. }
  1232. VARIANT Range::DialogBox_()
  1233. {
  1234. VARIANT result;
  1235. InvokeHelper(0xf5, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1236. return result;
  1237. }
  1238. LPDISPATCH Range::GetDirectDependents()
  1239. {
  1240. LPDISPATCH result;
  1241. InvokeHelper(0x221, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1242. return result;
  1243. }
  1244. LPDISPATCH Range::GetDirectPrecedents()
  1245. {
  1246. LPDISPATCH result;
  1247. InvokeHelper(0x222, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1248. return result;
  1249. }
  1250. VARIANT Range::EditionOptions(long Type, long Option, const VARIANT& Name, const VARIANT& Reference, long Appearance, long ChartSize, const VARIANT& Format)
  1251. {
  1252. VARIANT result;
  1253. static BYTE parms[] =
  1254. VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT;
  1255. InvokeHelper(0x46b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1256. Type, Option, &Name, &Reference, Appearance, ChartSize, &Format);
  1257. return result;
  1258. }
  1259. LPDISPATCH Range::GetEnd(long Direction)
  1260. {
  1261. LPDISPATCH result;
  1262. static BYTE parms[] =
  1263. VTS_I4;
  1264. InvokeHelper(0x1f4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  1265. Direction);
  1266. return result;
  1267. }
  1268. LPDISPATCH Range::GetEntireColumn()
  1269. {
  1270. LPDISPATCH result;
  1271. InvokeHelper(0xf6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1272. return result;
  1273. }
  1274. LPDISPATCH Range::GetEntireRow()
  1275. {
  1276. LPDISPATCH result;
  1277. InvokeHelper(0xf7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1278. return result;
  1279. }
  1280. VARIANT Range::FillDown()
  1281. {
  1282. VARIANT result;
  1283. InvokeHelper(0xf8, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1284. return result;
  1285. }
  1286. VARIANT Range::FillLeft()
  1287. {
  1288. VARIANT result;
  1289. InvokeHelper(0xf9, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1290. return result;
  1291. }
  1292. VARIANT Range::FillRight()
  1293. {
  1294. VARIANT result;
  1295. InvokeHelper(0xfa, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1296. return result;
  1297. }
  1298. VARIANT Range::FillUp()
  1299. {
  1300. VARIANT result;
  1301. InvokeHelper(0xfb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1302. return result;
  1303. }
  1304. LPDISPATCH Range::Find(const VARIANT& What, const VARIANT& After, const VARIANT& LookIn, const VARIANT& LookAt, const VARIANT& SearchOrder, long SearchDirection, const VARIANT& MatchCase, const VARIANT& MatchByte)
  1305. {
  1306. LPDISPATCH result;
  1307. static BYTE parms[] =
  1308. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT;
  1309. InvokeHelper(0x18e, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1310. &What, &After, &LookIn, &LookAt, &SearchOrder, SearchDirection, &MatchCase, &MatchByte);
  1311. return result;
  1312. }
  1313. LPDISPATCH Range::FindNext(const VARIANT& After)
  1314. {
  1315. LPDISPATCH result;
  1316. static BYTE parms[] =
  1317. VTS_VARIANT;
  1318. InvokeHelper(0x18f, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1319. &After);
  1320. return result;
  1321. }
  1322. LPDISPATCH Range::FindPrevious(const VARIANT& After)
  1323. {
  1324. LPDISPATCH result;
  1325. static BYTE parms[] =
  1326. VTS_VARIANT;
  1327. InvokeHelper(0x190, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1328. &After);
  1329. return result;
  1330. }
  1331. LPDISPATCH Range::GetFont()
  1332. {
  1333. LPDISPATCH result;
  1334. InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1335. return result;
  1336. }
  1337. VARIANT Range::GetFormula()
  1338. {
  1339. VARIANT result;
  1340. InvokeHelper(0x105, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1341. return result;
  1342. }
  1343. void Range::SetFormula(const VARIANT& newValue)
  1344. {
  1345. static BYTE parms[] =
  1346. VTS_VARIANT;
  1347. InvokeHelper(0x105, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1348.  &newValue);
  1349. }
  1350. VARIANT Range::GetFormulaArray()
  1351. {
  1352. VARIANT result;
  1353. InvokeHelper(0x24a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1354. return result;
  1355. }
  1356. void Range::SetFormulaArray(const VARIANT& newValue)
  1357. {
  1358. static BYTE parms[] =
  1359. VTS_VARIANT;
  1360. InvokeHelper(0x24a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1361.  &newValue);
  1362. }
  1363. long Range::GetFormulaLabel()
  1364. {
  1365. long result;
  1366. InvokeHelper(0x564, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  1367. return result;
  1368. }
  1369. void Range::SetFormulaLabel(long nNewValue)
  1370. {
  1371. static BYTE parms[] =
  1372. VTS_I4;
  1373. InvokeHelper(0x564, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1374.  nNewValue);
  1375. }
  1376. VARIANT Range::GetFormulaHidden()
  1377. {
  1378. VARIANT result;
  1379. InvokeHelper(0x106, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1380. return result;
  1381. }
  1382. void Range::SetFormulaHidden(const VARIANT& newValue)
  1383. {
  1384. static BYTE parms[] =
  1385. VTS_VARIANT;
  1386. InvokeHelper(0x106, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1387.  &newValue);
  1388. }
  1389. VARIANT Range::GetFormulaLocal()
  1390. {
  1391. VARIANT result;
  1392. InvokeHelper(0x107, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1393. return result;
  1394. }
  1395. void Range::SetFormulaLocal(const VARIANT& newValue)
  1396. {
  1397. static BYTE parms[] =
  1398. VTS_VARIANT;
  1399. InvokeHelper(0x107, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1400.  &newValue);
  1401. }
  1402. VARIANT Range::GetFormulaR1C1()
  1403. {
  1404. VARIANT result;
  1405. InvokeHelper(0x108, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1406. return result;
  1407. }
  1408. void Range::SetFormulaR1C1(const VARIANT& newValue)
  1409. {
  1410. static BYTE parms[] =
  1411. VTS_VARIANT;
  1412. InvokeHelper(0x108, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1413.  &newValue);
  1414. }
  1415. VARIANT Range::GetFormulaR1C1Local()
  1416. {
  1417. VARIANT result;
  1418. InvokeHelper(0x109, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1419. return result;
  1420. }
  1421. void Range::SetFormulaR1C1Local(const VARIANT& newValue)
  1422. {
  1423. static BYTE parms[] =
  1424. VTS_VARIANT;
  1425. InvokeHelper(0x109, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1426.  &newValue);
  1427. }
  1428. VARIANT Range::FunctionWizard()
  1429. {
  1430. VARIANT result;
  1431. InvokeHelper(0x23b, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1432. return result;
  1433. }
  1434. BOOL Range::GoalSeek(const VARIANT& Goal, LPDISPATCH ChangingCell)
  1435. {
  1436. BOOL result;
  1437. static BYTE parms[] =
  1438. VTS_VARIANT VTS_DISPATCH;
  1439. InvokeHelper(0x1d8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1440. &Goal, ChangingCell);
  1441. return result;
  1442. }
  1443. VARIANT Range::Group(const VARIANT& Start, const VARIANT& End, const VARIANT& By, const VARIANT& Periods)
  1444. {
  1445. VARIANT result;
  1446. static BYTE parms[] =
  1447. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1448. InvokeHelper(0x2e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1449. &Start, &End, &By, &Periods);
  1450. return result;
  1451. }
  1452. VARIANT Range::GetHasArray()
  1453. {
  1454. VARIANT result;
  1455. InvokeHelper(0x10a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1456. return result;
  1457. }
  1458. VARIANT Range::GetHasFormula()
  1459. {
  1460. VARIANT result;
  1461. InvokeHelper(0x10b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1462. return result;
  1463. }
  1464. VARIANT Range::GetHeight()
  1465. {
  1466. VARIANT result;
  1467. InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1468. return result;
  1469. }
  1470. VARIANT Range::GetHidden()
  1471. {
  1472. VARIANT result;
  1473. InvokeHelper(0x10c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1474. return result;
  1475. }
  1476. void Range::SetHidden(const VARIANT& newValue)
  1477. {
  1478. static BYTE parms[] =
  1479. VTS_VARIANT;
  1480. InvokeHelper(0x10c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1481.  &newValue);
  1482. }
  1483. VARIANT Range::GetHorizontalAlignment()
  1484. {
  1485. VARIANT result;
  1486. InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1487. return result;
  1488. }
  1489. void Range::SetHorizontalAlignment(const VARIANT& newValue)
  1490. {
  1491. static BYTE parms[] =
  1492. VTS_VARIANT;
  1493. InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1494.  &newValue);
  1495. }
  1496. VARIANT Range::GetIndentLevel()
  1497. {
  1498. VARIANT result;
  1499. InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1500. return result;
  1501. }
  1502. void Range::SetIndentLevel(const VARIANT& newValue)
  1503. {
  1504. static BYTE parms[] =
  1505. VTS_VARIANT;
  1506. InvokeHelper(0xc9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1507.  &newValue);
  1508. }
  1509. void Range::InsertIndent(long InsertAmount)
  1510. {
  1511. static BYTE parms[] =
  1512. VTS_I4;
  1513. InvokeHelper(0x565, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1514.  InsertAmount);
  1515. }
  1516. VARIANT Range::Insert(const VARIANT& Shift)
  1517. {
  1518. VARIANT result;
  1519. static BYTE parms[] =
  1520. VTS_VARIANT;
  1521. InvokeHelper(0xfc, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1522. &Shift);
  1523. return result;
  1524. }
  1525. LPDISPATCH Range::GetInterior()
  1526. {
  1527. LPDISPATCH result;
  1528. InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1529. return result;
  1530. }
  1531. VARIANT Range::GetItem(const VARIANT& RowIndex, const VARIANT& ColumnIndex)
  1532. {
  1533. VARIANT result;
  1534. static BYTE parms[] =
  1535. VTS_VARIANT VTS_VARIANT;
  1536. InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, parms,
  1537. &RowIndex, &ColumnIndex);
  1538. return result;
  1539. }
  1540. void Range::SetItem(const VARIANT& RowIndex, const VARIANT& ColumnIndex, const VARIANT& newValue)
  1541. {
  1542. static BYTE parms[] =
  1543. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1544. InvokeHelper(0xaa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1545.  &RowIndex, &ColumnIndex, &newValue);
  1546. }
  1547. VARIANT Range::Justify()
  1548. {
  1549. VARIANT result;
  1550. InvokeHelper(0x1ef, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1551. return result;
  1552. }
  1553. VARIANT Range::GetLeft()
  1554. {
  1555. VARIANT result;
  1556. InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1557. return result;
  1558. }
  1559. long Range::GetListHeaderRows()
  1560. {
  1561. long result;
  1562. InvokeHelper(0x4a3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  1563. return result;
  1564. }
  1565. VARIANT Range::ListNames()
  1566. {
  1567. VARIANT result;
  1568. InvokeHelper(0xfd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1569. return result;
  1570. }
  1571. long Range::GetLocationInTable()
  1572. {
  1573. long result;
  1574. InvokeHelper(0x2b3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  1575. return result;
  1576. }
  1577. VARIANT Range::GetLocked()
  1578. {
  1579. VARIANT result;
  1580. InvokeHelper(0x10d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1581. return result;
  1582. }
  1583. void Range::SetLocked(const VARIANT& newValue)
  1584. {
  1585. static BYTE parms[] =
  1586. VTS_VARIANT;
  1587. InvokeHelper(0x10d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1588.  &newValue);
  1589. }
  1590. void Range::Merge(const VARIANT& Across)
  1591. {
  1592. static BYTE parms[] =
  1593. VTS_VARIANT;
  1594. InvokeHelper(0x234, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1595.  &Across);
  1596. }
  1597. void Range::UnMerge()
  1598. {
  1599. InvokeHelper(0x568, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1600. }
  1601. LPDISPATCH Range::GetMergeArea()
  1602. {
  1603. LPDISPATCH result;
  1604. InvokeHelper(0x569, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1605. return result;
  1606. }
  1607. VARIANT Range::GetMergeCells()
  1608. {
  1609. VARIANT result;
  1610. InvokeHelper(0xd0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1611. return result;
  1612. }
  1613. void Range::SetMergeCells(const VARIANT& newValue)
  1614. {
  1615. static BYTE parms[] =
  1616. VTS_VARIANT;
  1617. InvokeHelper(0xd0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1618.  &newValue);
  1619. }
  1620. VARIANT Range::GetName()
  1621. {
  1622. VARIANT result;
  1623. InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1624. return result;
  1625. }
  1626. void Range::SetName(const VARIANT& newValue)
  1627. {
  1628. static BYTE parms[] =
  1629. VTS_VARIANT;
  1630. InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1631.  &newValue);
  1632. }
  1633. VARIANT Range::NavigateArrow(const VARIANT& TowardPrecedent, const VARIANT& ArrowNumber, const VARIANT& LinkNumber)
  1634. {
  1635. VARIANT result;
  1636. static BYTE parms[] =
  1637. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1638. InvokeHelper(0x408, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1639. &TowardPrecedent, &ArrowNumber, &LinkNumber);
  1640. return result;
  1641. }
  1642. LPUNKNOWN Range::Get_NewEnum()
  1643. {
  1644. LPUNKNOWN result;
  1645. InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
  1646. return result;
  1647. }
  1648. LPDISPATCH Range::GetNext()
  1649. {
  1650. LPDISPATCH result;
  1651. InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1652. return result;
  1653. }
  1654. CString Range::NoteText(const VARIANT& Text, const VARIANT& Start, const VARIANT& Length)
  1655. {
  1656. CString result;
  1657. static BYTE parms[] =
  1658. VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1659. InvokeHelper(0x467, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
  1660. &Text, &Start, &Length);
  1661. return result;
  1662. }
  1663. VARIANT Range::GetNumberFormat()
  1664. {
  1665. VARIANT result;
  1666. InvokeHelper(0xc1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1667. return result;
  1668. }
  1669. void Range::SetNumberFormat(const VARIANT& newValue)
  1670. {
  1671. static BYTE parms[] =
  1672. VTS_VARIANT;
  1673. InvokeHelper(0xc1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1674.  &newValue);
  1675. }
  1676. VARIANT Range::GetNumberFormatLocal()
  1677. {
  1678. VARIANT result;
  1679. InvokeHelper(0x449, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1680. return result;
  1681. }
  1682. void Range::SetNumberFormatLocal(const VARIANT& newValue)
  1683. {
  1684. static BYTE parms[] =
  1685. VTS_VARIANT;
  1686. InvokeHelper(0x449, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1687.  &newValue);
  1688. }
  1689. LPDISPATCH Range::GetOffset(const VARIANT& RowOffset, const VARIANT& ColumnOffset)
  1690. {
  1691. LPDISPATCH result;
  1692. static BYTE parms[] =
  1693. VTS_VARIANT VTS_VARIANT;
  1694. InvokeHelper(0xfe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  1695. &RowOffset, &ColumnOffset);
  1696. return result;
  1697. }
  1698. VARIANT Range::GetOrientation()
  1699. {
  1700. VARIANT result;
  1701. InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1702. return result;
  1703. }
  1704. void Range::SetOrientation(const VARIANT& newValue)
  1705. {
  1706. static BYTE parms[] =
  1707. VTS_VARIANT;
  1708. InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1709.  &newValue);
  1710. }
  1711. VARIANT Range::GetOutlineLevel()
  1712. {
  1713. VARIANT result;
  1714. InvokeHelper(0x10f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1715. return result;
  1716. }
  1717. void Range::SetOutlineLevel(const VARIANT& newValue)
  1718. {
  1719. static BYTE parms[] =
  1720. VTS_VARIANT;
  1721. InvokeHelper(0x10f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1722.  &newValue);
  1723. }
  1724. long Range::GetPageBreak()
  1725. {
  1726. long result;
  1727. InvokeHelper(0xff, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  1728. return result;
  1729. }
  1730. void Range::SetPageBreak(long nNewValue)
  1731. {
  1732. static BYTE parms[] =
  1733. VTS_I4;
  1734. InvokeHelper(0xff, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1735.  nNewValue);
  1736. }
  1737. VARIANT Range::Parse(const VARIANT& ParseLine, const VARIANT& Destination)
  1738. {
  1739. VARIANT result;
  1740. static BYTE parms[] =
  1741. VTS_VARIANT VTS_VARIANT;
  1742. InvokeHelper(0x1dd, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1743. &ParseLine, &Destination);
  1744. return result;
  1745. }
  1746. VARIANT Range::PasteSpecial(long Paste, long Operation, const VARIANT& SkipBlanks, const VARIANT& Transpose)
  1747. {
  1748. VARIANT result;
  1749. static BYTE parms[] =
  1750. VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT;
  1751. InvokeHelper(0x403, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1752. Paste, Operation, &SkipBlanks, &Transpose);
  1753. return result;
  1754. }
  1755. LPDISPATCH Range::GetPivotField()
  1756. {
  1757. LPDISPATCH result;
  1758. InvokeHelper(0x2db, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1759. return result;
  1760. }
  1761. LPDISPATCH Range::GetPivotItem()
  1762. {
  1763. LPDISPATCH result;
  1764. InvokeHelper(0x2e4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1765. return result;
  1766. }
  1767. LPDISPATCH Range::GetPivotTable()
  1768. {
  1769. LPDISPATCH result;
  1770. InvokeHelper(0x2cc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1771. return result;
  1772. }
  1773. LPDISPATCH Range::GetPrecedents()
  1774. {
  1775. LPDISPATCH result;
  1776. InvokeHelper(0x220, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1777. return result;
  1778. }
  1779. VARIANT Range::GetPrefixCharacter()
  1780. {
  1781. VARIANT result;
  1782. InvokeHelper(0x1f8, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1783. return result;
  1784. }
  1785. LPDISPATCH Range::GetPrevious()
  1786. {
  1787. LPDISPATCH result;
  1788. InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1789. return result;
  1790. }
  1791. VARIANT Range::_PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate)
  1792. {
  1793. VARIANT result;
  1794. static BYTE parms[] =
  1795. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1796. InvokeHelper(0x389, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1797. &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate);
  1798. return result;
  1799. }
  1800. VARIANT Range::PrintPreview(const VARIANT& EnableChanges)
  1801. {
  1802. VARIANT result;
  1803. static BYTE parms[] =
  1804. VTS_VARIANT;
  1805. InvokeHelper(0x119, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1806. &EnableChanges);
  1807. return result;
  1808. }
  1809. LPDISPATCH Range::GetQueryTable()
  1810. {
  1811. LPDISPATCH result;
  1812. InvokeHelper(0x56a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1813. return result;
  1814. }
  1815. LPDISPATCH Range::GetRange(const VARIANT& Cell1, const VARIANT& Cell2)
  1816. {
  1817. LPDISPATCH result;
  1818. static BYTE parms[] =
  1819. VTS_VARIANT VTS_VARIANT;
  1820. InvokeHelper(0xc5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  1821. &Cell1, &Cell2);
  1822. return result;
  1823. }
  1824. VARIANT Range::RemoveSubtotal()
  1825. {
  1826. VARIANT result;
  1827. InvokeHelper(0x373, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1828. return result;
  1829. }
  1830. BOOL Range::Replace(const VARIANT& What, const VARIANT& Replacement, const VARIANT& LookAt, const VARIANT& SearchOrder, const VARIANT& MatchCase, const VARIANT& MatchByte)
  1831. {
  1832. BOOL result;
  1833. static BYTE parms[] =
  1834. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1835. InvokeHelper(0xe2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1836. &What, &Replacement, &LookAt, &SearchOrder, &MatchCase, &MatchByte);
  1837. return result;
  1838. }
  1839. LPDISPATCH Range::GetResize(const VARIANT& RowSize, const VARIANT& ColumnSize)
  1840. {
  1841. LPDISPATCH result;
  1842. static BYTE parms[] =
  1843. VTS_VARIANT VTS_VARIANT;
  1844. InvokeHelper(0x100, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  1845. &RowSize, &ColumnSize);
  1846. return result;
  1847. }
  1848. long Range::GetRow()
  1849. {
  1850. long result;
  1851. InvokeHelper(0x101, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  1852. return result;
  1853. }
  1854. LPDISPATCH Range::RowDifferences(const VARIANT& Comparison)
  1855. {
  1856. LPDISPATCH result;
  1857. static BYTE parms[] =
  1858. VTS_VARIANT;
  1859. InvokeHelper(0x1ff, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1860. &Comparison);
  1861. return result;
  1862. }
  1863. VARIANT Range::GetRowHeight()
  1864. {
  1865. VARIANT result;
  1866. InvokeHelper(0x110, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1867. return result;
  1868. }
  1869. void Range::SetRowHeight(const VARIANT& newValue)
  1870. {
  1871. static BYTE parms[] =
  1872. VTS_VARIANT;
  1873. InvokeHelper(0x110, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1874.  &newValue);
  1875. }
  1876. LPDISPATCH Range::GetRows()
  1877. {
  1878. LPDISPATCH result;
  1879. InvokeHelper(0x102, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1880. return result;
  1881. }
  1882. VARIANT Range::Run(const VARIANT& Arg1, const VARIANT& Arg2, const VARIANT& Arg3, const VARIANT& Arg4, const VARIANT& Arg5, const VARIANT& Arg6, const VARIANT& Arg7, const VARIANT& Arg8, const VARIANT& Arg9, const VARIANT& Arg10,  const VARIANT& Arg11, const VARIANT& Arg12, const VARIANT& Arg13, const VARIANT& Arg14, const VARIANT& Arg15, const VARIANT& Arg16, const VARIANT& Arg17, const VARIANT& Arg18, const VARIANT& Arg19, const VARIANT& Arg20,  const VARIANT& Arg21, const VARIANT& Arg22, const VARIANT& Arg23, const VARIANT& Arg24, const VARIANT& Arg25, const VARIANT& Arg26, const VARIANT& Arg27, const VARIANT& Arg28, const VARIANT& Arg29, const VARIANT& Arg30)
  1883. {
  1884. VARIANT result;
  1885. static BYTE parms[] =
  1886. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT  VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  1887. InvokeHelper(0x103, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1888. &Arg1, &Arg2, &Arg3, &Arg4, &Arg5, &Arg6, &Arg7, &Arg8, &Arg9, &Arg10, &Arg11, &Arg12, &Arg13, &Arg14, &Arg15, &Arg16, &Arg17, &Arg18, &Arg19, &Arg20, &Arg21, &Arg22, &Arg23, &Arg24, &Arg25, &Arg26, &Arg27, &Arg28, &Arg29, &Arg30);
  1889. return result;
  1890. }
  1891. VARIANT Range::Select()
  1892. {
  1893. VARIANT result;
  1894. InvokeHelper(0xeb, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1895. return result;
  1896. }
  1897. VARIANT Range::Show()
  1898. {
  1899. VARIANT result;
  1900. InvokeHelper(0x1f0, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1901. return result;
  1902. }
  1903. VARIANT Range::ShowDependents(const VARIANT& Remove)
  1904. {
  1905. VARIANT result;
  1906. static BYTE parms[] =
  1907. VTS_VARIANT;
  1908. InvokeHelper(0x36d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1909. &Remove);
  1910. return result;
  1911. }
  1912. VARIANT Range::GetShowDetail()
  1913. {
  1914. VARIANT result;
  1915. InvokeHelper(0x249, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1916. return result;
  1917. }
  1918. void Range::SetShowDetail(const VARIANT& newValue)
  1919. {
  1920. static BYTE parms[] =
  1921. VTS_VARIANT;
  1922. InvokeHelper(0x249, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1923.  &newValue);
  1924. }
  1925. VARIANT Range::ShowErrors()
  1926. {
  1927. VARIANT result;
  1928. InvokeHelper(0x36e, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  1929. return result;
  1930. }
  1931. VARIANT Range::ShowPrecedents(const VARIANT& Remove)
  1932. {
  1933. VARIANT result;
  1934. static BYTE parms[] =
  1935. VTS_VARIANT;
  1936. InvokeHelper(0x36f, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1937. &Remove);
  1938. return result;
  1939. }
  1940. VARIANT Range::GetShrinkToFit()
  1941. {
  1942. VARIANT result;
  1943. InvokeHelper(0xd1, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1944. return result;
  1945. }
  1946. void Range::SetShrinkToFit(const VARIANT& newValue)
  1947. {
  1948. static BYTE parms[] =
  1949. VTS_VARIANT;
  1950. InvokeHelper(0xd1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1951.  &newValue);
  1952. }
  1953. VARIANT Range::Sort(const VARIANT& Key1, long Order1, const VARIANT& Key2, const VARIANT& Type, long Order2, const VARIANT& Key3, long Order3, long Header, const VARIANT& OrderCustom, const VARIANT& MatchCase, long Orientation, long SortMethod)
  1954. {
  1955. VARIANT result;
  1956. static BYTE parms[] =
  1957. VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_I4;
  1958. InvokeHelper(0x370, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1959. &Key1, Order1, &Key2, &Type, Order2, &Key3, Order3, Header, &OrderCustom, &MatchCase, Orientation, SortMethod);
  1960. return result;
  1961. }
  1962. VARIANT Range::SortSpecial(long SortMethod, const VARIANT& Key1, long Order1, const VARIANT& Type, const VARIANT& Key2, long Order2, const VARIANT& Key3, long Order3, long Header, const VARIANT& OrderCustom, const VARIANT& MatchCase,  long Orientation)
  1963. {
  1964. VARIANT result;
  1965. static BYTE parms[] =
  1966. VTS_I4 VTS_VARIANT VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4 VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_I4;
  1967. InvokeHelper(0x371, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  1968. SortMethod, &Key1, Order1, &Type, &Key2, Order2, &Key3, Order3, Header, &OrderCustom, &MatchCase, Orientation);
  1969. return result;
  1970. }
  1971. LPDISPATCH Range::GetSoundNote()
  1972. {
  1973. LPDISPATCH result;
  1974. InvokeHelper(0x394, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  1975. return result;
  1976. }
  1977. LPDISPATCH Range::SpecialCells(long Type, const VARIANT& Value)
  1978. {
  1979. LPDISPATCH result;
  1980. static BYTE parms[] =
  1981. VTS_I4 VTS_VARIANT;
  1982. InvokeHelper(0x19a, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  1983. Type, &Value);
  1984. return result;
  1985. }
  1986. VARIANT Range::GetStyle()
  1987. {
  1988. VARIANT result;
  1989. InvokeHelper(0x104, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  1990. return result;
  1991. }
  1992. void Range::SetStyle(const VARIANT& newValue)
  1993. {
  1994. static BYTE parms[] =
  1995. VTS_VARIANT;
  1996. InvokeHelper(0x104, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1997.  &newValue);
  1998. }
  1999. VARIANT Range::SubscribeTo(LPCTSTR Edition, long Format)
  2000. {
  2001. VARIANT result;
  2002. static BYTE parms[] =
  2003. VTS_BSTR VTS_I4;
  2004. InvokeHelper(0x1e1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  2005. Edition, Format);
  2006. return result;
  2007. }
  2008. VARIANT Range::Subtotal(long GroupBy, long Function, const VARIANT& TotalList, const VARIANT& Replace, const VARIANT& PageBreaks, long SummaryBelowData)
  2009. {
  2010. VARIANT result;
  2011. static BYTE parms[] =
  2012. VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_I4;
  2013. InvokeHelper(0x372, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  2014. GroupBy, Function, &TotalList, &Replace, &PageBreaks, SummaryBelowData);
  2015. return result;
  2016. }
  2017. VARIANT Range::GetSummary()
  2018. {
  2019. VARIANT result;
  2020. InvokeHelper(0x111, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2021. return result;
  2022. }
  2023. VARIANT Range::Table(const VARIANT& RowInput, const VARIANT& ColumnInput)
  2024. {
  2025. VARIANT result;
  2026. static BYTE parms[] =
  2027. VTS_VARIANT VTS_VARIANT;
  2028. InvokeHelper(0x1f1, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  2029. &RowInput, &ColumnInput);
  2030. return result;
  2031. }
  2032. VARIANT Range::GetText()
  2033. {
  2034. VARIANT result;
  2035. InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2036. return result;
  2037. }
  2038. VARIANT Range::TextToColumns(const VARIANT& Destination, long DataType, long TextQualifier, const VARIANT& ConsecutiveDelimiter, const VARIANT& Tab, const VARIANT& Semicolon, const VARIANT& Comma, const VARIANT& Space, const VARIANT& Other,  const VARIANT& OtherChar, const VARIANT& FieldInfo, const VARIANT& DecimalSeparator, const VARIANT& ThousandsSeparator)
  2039. {
  2040. VARIANT result;
  2041. static BYTE parms[] =
  2042. VTS_VARIANT VTS_I4 VTS_I4 VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  2043. InvokeHelper(0x410, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  2044. &Destination, DataType, TextQualifier, &ConsecutiveDelimiter, &Tab, &Semicolon, &Comma, &Space, &Other, &OtherChar, &FieldInfo, &DecimalSeparator, &ThousandsSeparator);
  2045. return result;
  2046. }
  2047. VARIANT Range::GetTop()
  2048. {
  2049. VARIANT result;
  2050. InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2051. return result;
  2052. }
  2053. VARIANT Range::Ungroup()
  2054. {
  2055. VARIANT result;
  2056. InvokeHelper(0xf4, DISPATCH_METHOD, VT_VARIANT, (void*)&result, NULL);
  2057. return result;
  2058. }
  2059. VARIANT Range::GetUseStandardHeight()
  2060. {
  2061. VARIANT result;
  2062. InvokeHelper(0x112, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2063. return result;
  2064. }
  2065. void Range::SetUseStandardHeight(const VARIANT& newValue)
  2066. {
  2067. static BYTE parms[] =
  2068. VTS_VARIANT;
  2069. InvokeHelper(0x112, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2070.  &newValue);
  2071. }
  2072. VARIANT Range::GetUseStandardWidth()
  2073. {
  2074. VARIANT result;
  2075. InvokeHelper(0x113, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2076. return result;
  2077. }
  2078. void Range::SetUseStandardWidth(const VARIANT& newValue)
  2079. {
  2080. static BYTE parms[] =
  2081. VTS_VARIANT;
  2082. InvokeHelper(0x113, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2083.  &newValue);
  2084. }
  2085. LPDISPATCH Range::GetValidation()
  2086. {
  2087. LPDISPATCH result;
  2088. InvokeHelper(0x56b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2089. return result;
  2090. }
  2091. VARIANT Range::GetValue()
  2092. {
  2093. VARIANT result;
  2094. InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2095. return result;
  2096. }
  2097. void Range::SetValue(const VARIANT& newValue)
  2098. {
  2099. static BYTE parms[] =
  2100. VTS_VARIANT;
  2101. InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2102.  &newValue);
  2103. }
  2104. VARIANT Range::GetValue2()
  2105. {
  2106. VARIANT result;
  2107. InvokeHelper(0x56c, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2108. return result;
  2109. }
  2110. void Range::SetValue2(const VARIANT& newValue)
  2111. {
  2112. static BYTE parms[] =
  2113. VTS_VARIANT;
  2114. InvokeHelper(0x56c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2115.  &newValue);
  2116. }
  2117. VARIANT Range::GetVerticalAlignment()
  2118. {
  2119. VARIANT result;
  2120. InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2121. return result;
  2122. }
  2123. void Range::SetVerticalAlignment(const VARIANT& newValue)
  2124. {
  2125. static BYTE parms[] =
  2126. VTS_VARIANT;
  2127. InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2128.  &newValue);
  2129. }
  2130. VARIANT Range::GetWidth()
  2131. {
  2132. VARIANT result;
  2133. InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2134. return result;
  2135. }
  2136. LPDISPATCH Range::GetWorksheet()
  2137. {
  2138. LPDISPATCH result;
  2139. InvokeHelper(0x15c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2140. return result;
  2141. }
  2142. VARIANT Range::GetWrapText()
  2143. {
  2144. VARIANT result;
  2145. InvokeHelper(0x114, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2146. return result;
  2147. }
  2148. void Range::SetWrapText(const VARIANT& newValue)
  2149. {
  2150. static BYTE parms[] =
  2151. VTS_VARIANT;
  2152. InvokeHelper(0x114, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2153.  &newValue);
  2154. }
  2155. LPDISPATCH Range::AddComment(const VARIANT& Text)
  2156. {
  2157. LPDISPATCH result;
  2158. static BYTE parms[] =
  2159. VTS_VARIANT;
  2160. InvokeHelper(0x56d, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2161. &Text);
  2162. return result;
  2163. }
  2164. LPDISPATCH Range::GetComment()
  2165. {
  2166. LPDISPATCH result;
  2167. InvokeHelper(0x38e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2168. return result;
  2169. }
  2170. void Range::ClearComments()
  2171. {
  2172. InvokeHelper(0x56e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2173. }
  2174. LPDISPATCH Range::GetPhonetic()
  2175. {
  2176. LPDISPATCH result;
  2177. InvokeHelper(0x56f, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2178. return result;
  2179. }
  2180. LPDISPATCH Range::GetFormatConditions()
  2181. {
  2182. LPDISPATCH result;
  2183. InvokeHelper(0x570, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2184. return result;
  2185. }
  2186. long Range::GetReadingOrder()
  2187. {
  2188. long result;
  2189. InvokeHelper(0x3cf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  2190. return result;
  2191. }
  2192. void Range::SetReadingOrder(long nNewValue)
  2193. {
  2194. static BYTE parms[] =
  2195. VTS_I4;
  2196. InvokeHelper(0x3cf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2197.  nNewValue);
  2198. }
  2199. LPDISPATCH Range::GetHyperlinks()
  2200. {
  2201. LPDISPATCH result;
  2202. InvokeHelper(0x571, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2203. return result;
  2204. }
  2205. LPDISPATCH Range::GetPhonetics()
  2206. {
  2207. LPDISPATCH result;
  2208. InvokeHelper(0x713, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2209. return result;
  2210. }
  2211. void Range::SetPhonetic()
  2212. {
  2213. InvokeHelper(0x714, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2214. }
  2215. CString Range::GetId()
  2216. {
  2217. CString result;
  2218. InvokeHelper(0x715, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  2219. return result;
  2220. }
  2221. void Range::SetId(LPCTSTR lpszNewValue)
  2222. {
  2223. static BYTE parms[] =
  2224. VTS_BSTR;
  2225. InvokeHelper(0x715, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2226.  lpszNewValue);
  2227. }
  2228. VARIANT Range::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName)
  2229. {
  2230. VARIANT result;
  2231. static BYTE parms[] =
  2232. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  2233. InvokeHelper(0x6ec, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  2234. &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName);
  2235. return result;
  2236. }
  2237. /////////////////////////////////////////////////////////////////////////////
  2238. // Borders properties
  2239. /////////////////////////////////////////////////////////////////////////////
  2240. // Borders operations
  2241. LPDISPATCH Borders::GetApplication()
  2242. {
  2243. LPDISPATCH result;
  2244. InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2245. return result;
  2246. }
  2247. long Borders::GetCreator()
  2248. {
  2249. long result;
  2250. InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  2251. return result;
  2252. }
  2253. LPDISPATCH Borders::GetParent()
  2254. {
  2255. LPDISPATCH result;
  2256. InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2257. return result;
  2258. }
  2259. VARIANT Borders::GetColor()
  2260. {
  2261. VARIANT result;
  2262. InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2263. return result;
  2264. }
  2265. void Borders::SetColor(const VARIANT& newValue)
  2266. {
  2267. static BYTE parms[] =
  2268. VTS_VARIANT;
  2269. InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2270.  &newValue);
  2271. }
  2272. VARIANT Borders::GetColorIndex()
  2273. {
  2274. VARIANT result;
  2275. InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2276. return result;
  2277. }
  2278. void Borders::SetColorIndex(const VARIANT& newValue)
  2279. {
  2280. static BYTE parms[] =
  2281. VTS_VARIANT;
  2282. InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2283.  &newValue);
  2284. }
  2285. long Borders::GetCount()
  2286. {
  2287. long result;
  2288. InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  2289. return result;
  2290. }
  2291. LPDISPATCH Borders::GetItem(long Index)
  2292. {
  2293. LPDISPATCH result;
  2294. static BYTE parms[] =
  2295. VTS_I4;
  2296. InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  2297. Index);
  2298. return result;
  2299. }
  2300. VARIANT Borders::GetLineStyle()
  2301. {
  2302. VARIANT result;
  2303. InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2304. return result;
  2305. }
  2306. void Borders::SetLineStyle(const VARIANT& newValue)
  2307. {
  2308. static BYTE parms[] =
  2309. VTS_VARIANT;
  2310. InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2311.  &newValue);
  2312. }
  2313. LPUNKNOWN Borders::Get_NewEnum()
  2314. {
  2315. LPUNKNOWN result;
  2316. InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
  2317. return result;
  2318. }
  2319. VARIANT Borders::GetValue()
  2320. {
  2321. VARIANT result;
  2322. InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2323. return result;
  2324. }
  2325. void Borders::SetValue(const VARIANT& newValue)
  2326. {
  2327. static BYTE parms[] =
  2328. VTS_VARIANT;
  2329. InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2330.  &newValue);
  2331. }
  2332. VARIANT Borders::GetWeight()
  2333. {
  2334. VARIANT result;
  2335. InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2336. return result;
  2337. }
  2338. void Borders::SetWeight(const VARIANT& newValue)
  2339. {
  2340. static BYTE parms[] =
  2341. VTS_VARIANT;
  2342. InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2343.  &newValue);
  2344. }
  2345. LPDISPATCH Borders::Get_Default(long Index)
  2346. {
  2347. LPDISPATCH result;
  2348. static BYTE parms[] =
  2349. VTS_I4;
  2350. InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  2351. Index);
  2352. return result;
  2353. }
  2354. /////////////////////////////////////////////////////////////////////////////
  2355. // Worksheets properties
  2356. /////////////////////////////////////////////////////////////////////////////
  2357. // Worksheets operations
  2358. LPDISPATCH Worksheets::GetApplication()
  2359. {
  2360. LPDISPATCH result;
  2361. InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2362. return result;
  2363. }
  2364. long Worksheets::GetCreator()
  2365. {
  2366. long result;
  2367. InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  2368. return result;
  2369. }
  2370. LPDISPATCH Worksheets::GetParent()
  2371. {
  2372. LPDISPATCH result;
  2373. InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2374. return result;
  2375. }
  2376. LPDISPATCH Worksheets::Add(const VARIANT& Before, const VARIANT& After, const VARIANT& Count, const VARIANT& Type)
  2377. {
  2378. LPDISPATCH result;
  2379. static BYTE parms[] =
  2380. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  2381. InvokeHelper(0xb5, DISPATCH_METHOD, VT_DISPATCH, (void*)&result, parms,
  2382. &Before, &After, &Count, &Type);
  2383. return result;
  2384. }
  2385. void Worksheets::Copy(const VARIANT& Before, const VARIANT& After)
  2386. {
  2387. static BYTE parms[] =
  2388. VTS_VARIANT VTS_VARIANT;
  2389. InvokeHelper(0x227, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2390.  &Before, &After);
  2391. }
  2392. long Worksheets::GetCount()
  2393. {
  2394. long result;
  2395. InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  2396. return result;
  2397. }
  2398. void Worksheets::Delete()
  2399. {
  2400. InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2401. }
  2402. void Worksheets::FillAcrossSheets(LPDISPATCH Range, long Type)
  2403. {
  2404. static BYTE parms[] =
  2405. VTS_DISPATCH VTS_I4;
  2406. InvokeHelper(0x1d5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2407.  Range, Type);
  2408. }
  2409. LPDISPATCH Worksheets::GetItem(const VARIANT& Index)
  2410. {
  2411. LPDISPATCH result;
  2412. static BYTE parms[] =
  2413. VTS_VARIANT;
  2414. InvokeHelper(0xaa, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  2415. &Index);
  2416. return result;
  2417. }
  2418. void Worksheets::Move(const VARIANT& Before, const VARIANT& After)
  2419. {
  2420. static BYTE parms[] =
  2421. VTS_VARIANT VTS_VARIANT;
  2422. InvokeHelper(0x27d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2423.  &Before, &After);
  2424. }
  2425. LPUNKNOWN Worksheets::Get_NewEnum()
  2426. {
  2427. LPUNKNOWN result;
  2428. InvokeHelper(0xfffffffc, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
  2429. return result;
  2430. }
  2431. void Worksheets::PrintPreview(const VARIANT& EnableChanges)
  2432. {
  2433. static BYTE parms[] =
  2434. VTS_VARIANT;
  2435. InvokeHelper(0x119, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2436.  &EnableChanges);
  2437. }
  2438. void Worksheets::Select(const VARIANT& Replace)
  2439. {
  2440. static BYTE parms[] =
  2441. VTS_VARIANT;
  2442. InvokeHelper(0xeb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2443.  &Replace);
  2444. }
  2445. LPDISPATCH Worksheets::GetHPageBreaks()
  2446. {
  2447. LPDISPATCH result;
  2448. InvokeHelper(0x58a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2449. return result;
  2450. }
  2451. LPDISPATCH Worksheets::GetVPageBreaks()
  2452. {
  2453. LPDISPATCH result;
  2454. InvokeHelper(0x58b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2455. return result;
  2456. }
  2457. VARIANT Worksheets::GetVisible()
  2458. {
  2459. VARIANT result;
  2460. InvokeHelper(0x22e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2461. return result;
  2462. }
  2463. void Worksheets::SetVisible(const VARIANT& newValue)
  2464. {
  2465. static BYTE parms[] =
  2466. VTS_VARIANT;
  2467. InvokeHelper(0x22e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2468.  &newValue);
  2469. }
  2470. LPDISPATCH Worksheets::Get_Default(const VARIANT& Index)
  2471. {
  2472. LPDISPATCH result;
  2473. static BYTE parms[] =
  2474. VTS_VARIANT;
  2475. InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, parms,
  2476. &Index);
  2477. return result;
  2478. }
  2479. void Worksheets::PrintOut(const VARIANT& From, const VARIANT& To, const VARIANT& Copies, const VARIANT& Preview, const VARIANT& ActivePrinter, const VARIANT& PrintToFile, const VARIANT& Collate, const VARIANT& PrToFileName)
  2480. {
  2481. static BYTE parms[] =
  2482. VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT VTS_VARIANT;
  2483. InvokeHelper(0x6ec, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2484.  &From, &To, &Copies, &Preview, &ActivePrinter, &PrintToFile, &Collate, &PrToFileName);
  2485. }
  2486. /////////////////////////////////////////////////////////////////////////////
  2487. // Interior properties
  2488. /////////////////////////////////////////////////////////////////////////////
  2489. // Interior operations
  2490. LPDISPATCH Interior::GetApplication()
  2491. {
  2492. LPDISPATCH result;
  2493. InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2494. return result;
  2495. }
  2496. long Interior::GetCreator()
  2497. {
  2498. long result;
  2499. InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  2500. return result;
  2501. }
  2502. LPDISPATCH Interior::GetParent()
  2503. {
  2504. LPDISPATCH result;
  2505. InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2506. return result;
  2507. }
  2508. VARIANT Interior::GetColor()
  2509. {
  2510. VARIANT result;
  2511. InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2512. return result;
  2513. }
  2514. void Interior::SetColor(const VARIANT& newValue)
  2515. {
  2516. static BYTE parms[] =
  2517. VTS_VARIANT;
  2518. InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2519.  &newValue);
  2520. }
  2521. VARIANT Interior::GetColorIndex()
  2522. {
  2523. VARIANT result;
  2524. InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2525. return result;
  2526. }
  2527. void Interior::SetColorIndex(const VARIANT& newValue)
  2528. {
  2529. static BYTE parms[] =
  2530. VTS_VARIANT;
  2531. InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2532.  &newValue);
  2533. }
  2534. VARIANT Interior::GetInvertIfNegative()
  2535. {
  2536. VARIANT result;
  2537. InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2538. return result;
  2539. }
  2540. void Interior::SetInvertIfNegative(const VARIANT& newValue)
  2541. {
  2542. static BYTE parms[] =
  2543. VTS_VARIANT;
  2544. InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2545.  &newValue);
  2546. }
  2547. VARIANT Interior::GetPattern()
  2548. {
  2549. VARIANT result;
  2550. InvokeHelper(0x5f, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2551. return result;
  2552. }
  2553. void Interior::SetPattern(const VARIANT& newValue)
  2554. {
  2555. static BYTE parms[] =
  2556. VTS_VARIANT;
  2557. InvokeHelper(0x5f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2558.  &newValue);
  2559. }
  2560. VARIANT Interior::GetPatternColor()
  2561. {
  2562. VARIANT result;
  2563. InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2564. return result;
  2565. }
  2566. void Interior::SetPatternColor(const VARIANT& newValue)
  2567. {
  2568. static BYTE parms[] =
  2569. VTS_VARIANT;
  2570. InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2571.  &newValue);
  2572. }
  2573. VARIANT Interior::GetPatternColorIndex()
  2574. {
  2575. VARIANT result;
  2576. InvokeHelper(0x62, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2577. return result;
  2578. }
  2579. void Interior::SetPatternColorIndex(const VARIANT& newValue)
  2580. {
  2581. static BYTE parms[] =
  2582. VTS_VARIANT;
  2583. InvokeHelper(0x62, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2584.  &newValue);
  2585. }
  2586. /////////////////////////////////////////////////////////////////////////////
  2587. // Border properties
  2588. /////////////////////////////////////////////////////////////////////////////
  2589. // Border operations
  2590. LPDISPATCH Border::GetApplication()
  2591. {
  2592. LPDISPATCH result;
  2593. InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2594. return result;
  2595. }
  2596. long Border::GetCreator()
  2597. {
  2598. long result;
  2599. InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  2600. return result;
  2601. }
  2602. LPDISPATCH Border::GetParent()
  2603. {
  2604. LPDISPATCH result;
  2605. InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  2606. return result;
  2607. }
  2608. VARIANT Border::GetColor()
  2609. {
  2610. VARIANT result;
  2611. InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2612. return result;
  2613. }
  2614. void Border::SetColor(const VARIANT& newValue)
  2615. {
  2616. static BYTE parms[] =
  2617. VTS_VARIANT;
  2618. InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2619.  &newValue);
  2620. }
  2621. VARIANT Border::GetColorIndex()
  2622. {
  2623. VARIANT result;
  2624. InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2625. return result;
  2626. }
  2627. void Border::SetColorIndex(const VARIANT& newValue)
  2628. {
  2629. static BYTE parms[] =
  2630. VTS_VARIANT;
  2631. InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2632.  &newValue);
  2633. }
  2634. VARIANT Border::GetLineStyle()
  2635. {
  2636. VARIANT result;
  2637. InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2638. return result;
  2639. }
  2640. void Border::SetLineStyle(const VARIANT& newValue)
  2641. {
  2642. static BYTE parms[] =
  2643. VTS_VARIANT;
  2644. InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2645.  &newValue);
  2646. }
  2647. VARIANT Border::GetWeight()
  2648. {
  2649. VARIANT result;
  2650. InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  2651. return result;
  2652. }
  2653. void Border::SetWeight(const VARIANT& newValue)
  2654. {
  2655. static BYTE parms[] =
  2656. VTS_VARIANT;
  2657. InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2658.  &newValue);
  2659. }