datagrid.cpp
上传用户:xz12345
上传日期:2007-09-12
资源大小:7437k
文件大小:18k
源码类别:

数据库编程

开发平台:

Visual C++

  1. // Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
  2. // NOTE: Do not modify the contents of this file.  If this class is regenerated by
  3. //  Microsoft Visual C++, your modifications will be overwritten.
  4. #include "stdafx.h"
  5. #include "datagrid.h"
  6. // Dispatch interfaces referenced by this interface
  7. #include "font.h"
  8. #include "StdDataFormatsDisp.h"
  9. #include "Picture.h"
  10. #include "Columns.h"
  11. #include "SelBookmarks.h"
  12. #include "Splits.h"
  13. /////////////////////////////////////////////////////////////////////////////
  14. // CDataGrid
  15. IMPLEMENT_DYNCREATE(CDataGrid, CWnd)
  16. /////////////////////////////////////////////////////////////////////////////
  17. // CDataGrid properties
  18. /////////////////////////////////////////////////////////////////////////////
  19. // CDataGrid operations
  20. long CDataGrid::GetAddNewMode()
  21. {
  22. long result;
  23. InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  24. return result;
  25. }
  26. BOOL CDataGrid::GetAllowAddNew()
  27. {
  28. BOOL result;
  29. InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  30. return result;
  31. }
  32. void CDataGrid::SetAllowAddNew(BOOL bNewValue)
  33. {
  34. static BYTE parms[] =
  35. VTS_BOOL;
  36. InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  37.  bNewValue);
  38. }
  39. BOOL CDataGrid::GetAllowArrows()
  40. {
  41. BOOL result;
  42. InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  43. return result;
  44. }
  45. void CDataGrid::SetAllowArrows(BOOL bNewValue)
  46. {
  47. static BYTE parms[] =
  48. VTS_BOOL;
  49. InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  50.  bNewValue);
  51. }
  52. BOOL CDataGrid::GetAllowDelete()
  53. {
  54. BOOL result;
  55. InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  56. return result;
  57. }
  58. void CDataGrid::SetAllowDelete(BOOL bNewValue)
  59. {
  60. static BYTE parms[] =
  61. VTS_BOOL;
  62. InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  63.  bNewValue);
  64. }
  65. BOOL CDataGrid::GetAllowRowSizing()
  66. {
  67. BOOL result;
  68. InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  69. return result;
  70. }
  71. void CDataGrid::SetAllowRowSizing(BOOL bNewValue)
  72. {
  73. static BYTE parms[] =
  74. VTS_BOOL;
  75. InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  76.  bNewValue);
  77. }
  78. BOOL CDataGrid::GetAllowUpdate()
  79. {
  80. BOOL result;
  81. InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  82. return result;
  83. }
  84. void CDataGrid::SetAllowUpdate(BOOL bNewValue)
  85. {
  86. static BYTE parms[] =
  87. VTS_BOOL;
  88. InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  89.  bNewValue);
  90. }
  91. long CDataGrid::GetAppearance()
  92. {
  93. long result;
  94. InvokeHelper(DISPID_APPEARANCE, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  95. return result;
  96. }
  97. void CDataGrid::SetAppearance(long nNewValue)
  98. {
  99. static BYTE parms[] =
  100. VTS_I4;
  101. InvokeHelper(DISPID_APPEARANCE, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  102.  nNewValue);
  103. }
  104. long CDataGrid::GetApproxCount()
  105. {
  106. long result;
  107. InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  108. return result;
  109. }
  110. unsigned long CDataGrid::GetBackColor()
  111. {
  112. unsigned long result;
  113. InvokeHelper(DISPID_BACKCOLOR, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  114. return result;
  115. }
  116. void CDataGrid::SetBackColor(unsigned long newValue)
  117. {
  118. static BYTE parms[] =
  119. VTS_I4;
  120. InvokeHelper(DISPID_BACKCOLOR, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  121.  newValue);
  122. }
  123. VARIANT CDataGrid::GetBookmark()
  124. {
  125. VARIANT result;
  126. InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  127. return result;
  128. }
  129. void CDataGrid::SetBookmark(const VARIANT& newValue)
  130. {
  131. static BYTE parms[] =
  132. VTS_VARIANT;
  133. InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  134.  &newValue);
  135. }
  136. long CDataGrid::GetBorderStyle()
  137. {
  138. long result;
  139. InvokeHelper(DISPID_BORDERSTYLE, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  140. return result;
  141. }
  142. void CDataGrid::SetBorderStyle(long nNewValue)
  143. {
  144. static BYTE parms[] =
  145. VTS_I4;
  146. InvokeHelper(DISPID_BORDERSTYLE, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  147.  nNewValue);
  148. }
  149. CString CDataGrid::GetCaption()
  150. {
  151. CString result;
  152. InvokeHelper(DISPID_CAPTION, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  153. return result;
  154. }
  155. void CDataGrid::SetCaption(LPCTSTR lpszNewValue)
  156. {
  157. static BYTE parms[] =
  158. VTS_BSTR;
  159. InvokeHelper(DISPID_CAPTION, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  160.  lpszNewValue);
  161. }
  162. short CDataGrid::GetCol()
  163. {
  164. short result;
  165. InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  166. return result;
  167. }
  168. void CDataGrid::SetCol(short nNewValue)
  169. {
  170. static BYTE parms[] =
  171. VTS_I2;
  172. InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  173.  nNewValue);
  174. }
  175. BOOL CDataGrid::GetColumnHeaders()
  176. {
  177. BOOL result;
  178. InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  179. return result;
  180. }
  181. void CDataGrid::SetColumnHeaders(BOOL bNewValue)
  182. {
  183. static BYTE parms[] =
  184. VTS_BOOL;
  185. InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  186.  bNewValue);
  187. }
  188. BOOL CDataGrid::GetCurrentCellModified()
  189. {
  190. BOOL result;
  191. InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  192. return result;
  193. }
  194. void CDataGrid::SetCurrentCellModified(BOOL bNewValue)
  195. {
  196. static BYTE parms[] =
  197. VTS_BOOL;
  198. InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  199.  bNewValue);
  200. }
  201. BOOL CDataGrid::GetCurrentCellVisible()
  202. {
  203. BOOL result;
  204. InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  205. return result;
  206. }
  207. void CDataGrid::SetCurrentCellVisible(BOOL bNewValue)
  208. {
  209. static BYTE parms[] =
  210. VTS_BOOL;
  211. InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  212.  bNewValue);
  213. }
  214. BOOL CDataGrid::GetDataChanged()
  215. {
  216. BOOL result;
  217. InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  218. return result;
  219. }
  220. void CDataGrid::SetDataChanged(BOOL bNewValue)
  221. {
  222. static BYTE parms[] =
  223. VTS_BOOL;
  224. InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  225.  bNewValue);
  226. }
  227. LPUNKNOWN CDataGrid::GetDataSource()
  228. {
  229. LPUNKNOWN result;
  230. InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_UNKNOWN, (void*)&result, NULL);
  231. return result;
  232. }
  233. void CDataGrid::SetRefDataSource(LPUNKNOWN newValue)
  234. {
  235. static BYTE parms[] =
  236. VTS_UNKNOWN;
  237. InvokeHelper(0x2a, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  238.  newValue);
  239. }
  240. CString CDataGrid::GetDataMember()
  241. {
  242. CString result;
  243. InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  244. return result;
  245. }
  246. void CDataGrid::SetDataMember(LPCTSTR lpszNewValue)
  247. {
  248. static BYTE parms[] =
  249. VTS_BSTR;
  250. InvokeHelper(0x2b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  251.  lpszNewValue);
  252. }
  253. float CDataGrid::GetDefColWidth()
  254. {
  255. float result;
  256. InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  257. return result;
  258. }
  259. void CDataGrid::SetDefColWidth(float newValue)
  260. {
  261. static BYTE parms[] =
  262. VTS_R4;
  263. InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  264.  newValue);
  265. }
  266. BOOL CDataGrid::GetEditActive()
  267. {
  268. BOOL result;
  269. InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  270. return result;
  271. }
  272. void CDataGrid::SetEditActive(BOOL bNewValue)
  273. {
  274. static BYTE parms[] =
  275. VTS_BOOL;
  276. InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  277.  bNewValue);
  278. }
  279. BOOL CDataGrid::GetEnabled()
  280. {
  281. BOOL result;
  282. InvokeHelper(DISPID_ENABLED, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  283. return result;
  284. }
  285. void CDataGrid::SetEnabled(BOOL bNewValue)
  286. {
  287. static BYTE parms[] =
  288. VTS_BOOL;
  289. InvokeHelper(DISPID_ENABLED, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  290.  bNewValue);
  291. }
  292. CString CDataGrid::GetErrorText()
  293. {
  294. CString result;
  295. InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  296. return result;
  297. }
  298. COleFont CDataGrid::GetFont()
  299. {
  300. LPDISPATCH pDispatch;
  301. InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  302. return COleFont(pDispatch);
  303. }
  304. void CDataGrid::SetRefFont(LPDISPATCH newValue)
  305. {
  306. static BYTE parms[] =
  307. VTS_DISPATCH;
  308. InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  309.  newValue);
  310. }
  311. unsigned long CDataGrid::GetForeColor()
  312. {
  313. unsigned long result;
  314. InvokeHelper(DISPID_FORECOLOR, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  315. return result;
  316. }
  317. void CDataGrid::SetForeColor(unsigned long newValue)
  318. {
  319. static BYTE parms[] =
  320. VTS_I4;
  321. InvokeHelper(DISPID_FORECOLOR, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  322.  newValue);
  323. }
  324. VARIANT CDataGrid::GetFirstRow()
  325. {
  326. VARIANT result;
  327. InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  328. return result;
  329. }
  330. void CDataGrid::SetFirstRow(const VARIANT& newValue)
  331. {
  332. static BYTE parms[] =
  333. VTS_VARIANT;
  334. InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  335.  &newValue);
  336. }
  337. COleFont CDataGrid::GetHeadFont()
  338. {
  339. LPDISPATCH pDispatch;
  340. InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  341. return COleFont(pDispatch);
  342. }
  343. void CDataGrid::SetRefHeadFont(LPDISPATCH newValue)
  344. {
  345. static BYTE parms[] =
  346. VTS_DISPATCH;
  347. InvokeHelper(0x14, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  348.  newValue);
  349. }
  350. float CDataGrid::GetHeadLines()
  351. {
  352. float result;
  353. InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  354. return result;
  355. }
  356. void CDataGrid::SetHeadLines(float newValue)
  357. {
  358. static BYTE parms[] =
  359. VTS_R4;
  360. InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  361.  newValue);
  362. }
  363. long CDataGrid::GetHWnd()
  364. {
  365. long result;
  366. InvokeHelper(DISPID_HWND, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  367. return result;
  368. }
  369. long CDataGrid::GetHWndEditor()
  370. {
  371. long result;
  372. InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  373. return result;
  374. }
  375. short CDataGrid::GetLeftCol()
  376. {
  377. short result;
  378. InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  379. return result;
  380. }
  381. void CDataGrid::SetLeftCol(short nNewValue)
  382. {
  383. static BYTE parms[] =
  384. VTS_I2;
  385. InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  386.  nNewValue);
  387. }
  388. long CDataGrid::GetMarqueeStyle()
  389. {
  390. long result;
  391. InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  392. return result;
  393. }
  394. void CDataGrid::SetMarqueeStyle(long nNewValue)
  395. {
  396. static BYTE parms[] =
  397. VTS_I4;
  398. InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  399.  nNewValue);
  400. }
  401. BOOL CDataGrid::GetRecordSelectors()
  402. {
  403. BOOL result;
  404. InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  405. return result;
  406. }
  407. void CDataGrid::SetRecordSelectors(BOOL bNewValue)
  408. {
  409. static BYTE parms[] =
  410. VTS_BOOL;
  411. InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  412.  bNewValue);
  413. }
  414. BOOL CDataGrid::GetRightToLeft()
  415. {
  416. BOOL result;
  417. InvokeHelper(0xfffffd9d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  418. return result;
  419. }
  420. void CDataGrid::SetRightToLeft(BOOL bNewValue)
  421. {
  422. static BYTE parms[] =
  423. VTS_BOOL;
  424. InvokeHelper(0xfffffd9d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  425.  bNewValue);
  426. }
  427. short CDataGrid::GetRow()
  428. {
  429. short result;
  430. InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  431. return result;
  432. }
  433. void CDataGrid::SetRow(short nNewValue)
  434. {
  435. static BYTE parms[] =
  436. VTS_I2;
  437. InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  438.  nNewValue);
  439. }
  440. long CDataGrid::GetRowDividerStyle()
  441. {
  442. long result;
  443. InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  444. return result;
  445. }
  446. void CDataGrid::SetRowDividerStyle(long nNewValue)
  447. {
  448. static BYTE parms[] =
  449. VTS_I4;
  450. InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  451.  nNewValue);
  452. }
  453. float CDataGrid::GetRowHeight()
  454. {
  455. float result;
  456. InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  457. return result;
  458. }
  459. void CDataGrid::SetRowHeight(float newValue)
  460. {
  461. static BYTE parms[] =
  462. VTS_R4;
  463. InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  464.  newValue);
  465. }
  466. long CDataGrid::GetScrollBars()
  467. {
  468. long result;
  469. InvokeHelper(0xfffffde9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  470. return result;
  471. }
  472. void CDataGrid::SetScrollBars(long nNewValue)
  473. {
  474. static BYTE parms[] =
  475. VTS_I4;
  476. InvokeHelper(0xfffffde9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  477.  nNewValue);
  478. }
  479. short CDataGrid::GetSelEndCol()
  480. {
  481. short result;
  482. InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  483. return result;
  484. }
  485. void CDataGrid::SetSelEndCol(short nNewValue)
  486. {
  487. static BYTE parms[] =
  488. VTS_I2;
  489. InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  490.  nNewValue);
  491. }
  492. long CDataGrid::GetSelLength()
  493. {
  494. long result;
  495. InvokeHelper(0xfffffddc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  496. return result;
  497. }
  498. void CDataGrid::SetSelLength(long nNewValue)
  499. {
  500. static BYTE parms[] =
  501. VTS_I4;
  502. InvokeHelper(0xfffffddc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  503.  nNewValue);
  504. }
  505. long CDataGrid::GetSelStart()
  506. {
  507. long result;
  508. InvokeHelper(0xfffffddd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  509. return result;
  510. }
  511. void CDataGrid::SetSelStart(long nNewValue)
  512. {
  513. static BYTE parms[] =
  514. VTS_I4;
  515. InvokeHelper(0xfffffddd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  516.  nNewValue);
  517. }
  518. short CDataGrid::GetSelStartCol()
  519. {
  520. short result;
  521. InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  522. return result;
  523. }
  524. void CDataGrid::SetSelStartCol(short nNewValue)
  525. {
  526. static BYTE parms[] =
  527. VTS_I2;
  528. InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  529.  nNewValue);
  530. }
  531. CString CDataGrid::GetSelText()
  532. {
  533. CString result;
  534. InvokeHelper(0xfffffdde, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  535. return result;
  536. }
  537. void CDataGrid::SetSelText(LPCTSTR lpszNewValue)
  538. {
  539. static BYTE parms[] =
  540. VTS_BSTR;
  541. InvokeHelper(0xfffffdde, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  542.  lpszNewValue);
  543. }
  544. short CDataGrid::GetSplit()
  545. {
  546. short result;
  547. InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  548. return result;
  549. }
  550. void CDataGrid::SetSplit(short nNewValue)
  551. {
  552. static BYTE parms[] =
  553. VTS_I2;
  554. InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  555.  nNewValue);
  556. }
  557. BOOL CDataGrid::GetTabAcrossSplits()
  558. {
  559. BOOL result;
  560. InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  561. return result;
  562. }
  563. void CDataGrid::SetTabAcrossSplits(BOOL bNewValue)
  564. {
  565. static BYTE parms[] =
  566. VTS_BOOL;
  567. InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  568.  bNewValue);
  569. }
  570. long CDataGrid::GetTabAction()
  571. {
  572. long result;
  573. InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  574. return result;
  575. }
  576. void CDataGrid::SetTabAction(long nNewValue)
  577. {
  578. static BYTE parms[] =
  579. VTS_I4;
  580. InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  581.  nNewValue);
  582. }
  583. CString CDataGrid::GetText()
  584. {
  585. CString result;
  586. InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  587. return result;
  588. }
  589. void CDataGrid::SetText(LPCTSTR lpszNewValue)
  590. {
  591. static BYTE parms[] =
  592. VTS_BSTR;
  593. InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  594.  lpszNewValue);
  595. }
  596. short CDataGrid::GetVisibleCols()
  597. {
  598. short result;
  599. InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  600. return result;
  601. }
  602. short CDataGrid::GetVisibleRows()
  603. {
  604. short result;
  605. InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  606. return result;
  607. }
  608. BOOL CDataGrid::GetWrapCellPointer()
  609. {
  610. BOOL result;
  611. InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  612. return result;
  613. }
  614. void CDataGrid::SetWrapCellPointer(BOOL bNewValue)
  615. {
  616. static BYTE parms[] =
  617. VTS_BOOL;
  618. InvokeHelper(0x29, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  619.  bNewValue);
  620. }
  621. CStdDataFormatsDisp CDataGrid::GetDataFormats()
  622. {
  623. LPDISPATCH pDispatch;
  624. InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  625. return CStdDataFormatsDisp(pDispatch);
  626. }
  627. CPicture CDataGrid::CaptureImage()
  628. {
  629. LPDISPATCH pDispatch;
  630. InvokeHelper(0x65, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
  631. return CPicture(pDispatch);
  632. }
  633. void CDataGrid::ClearSelCols()
  634. {
  635. InvokeHelper(0x66, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  636. }
  637. void CDataGrid::ClearFields()
  638. {
  639. InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  640. }
  641. short CDataGrid::ColContaining(float X)
  642. {
  643. short result;
  644. static BYTE parms[] =
  645. VTS_R4;
  646. InvokeHelper(0x68, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  647. X);
  648. return result;
  649. }
  650. CColumns CDataGrid::GetColumns()
  651. {
  652. LPDISPATCH pDispatch;
  653. InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  654. return CColumns(pDispatch);
  655. }
  656. VARIANT CDataGrid::GetBookmark(long RowNum)
  657. {
  658. VARIANT result;
  659. static BYTE parms[] =
  660. VTS_I4;
  661. InvokeHelper(0x6a, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  662. RowNum);
  663. return result;
  664. }
  665. void CDataGrid::HoldFields()
  666. {
  667. InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  668. }
  669. void CDataGrid::ReBind()
  670. {
  671. InvokeHelper(0x6c, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  672. }
  673. void CDataGrid::Refresh()
  674. {
  675. InvokeHelper(DISPID_REFRESH, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  676. }
  677. VARIANT CDataGrid::RowBookmark(short RowNum)
  678. {
  679. VARIANT result;
  680. static BYTE parms[] =
  681. VTS_I2;
  682. InvokeHelper(0x6d, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
  683. RowNum);
  684. return result;
  685. }
  686. short CDataGrid::RowContaining(float Y)
  687. {
  688. short result;
  689. static BYTE parms[] =
  690. VTS_R4;
  691. InvokeHelper(0x6e, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  692. Y);
  693. return result;
  694. }
  695. float CDataGrid::RowTop(short RowNum)
  696. {
  697. float result;
  698. static BYTE parms[] =
  699. VTS_I2;
  700. InvokeHelper(0x6f, DISPATCH_METHOD, VT_R4, (void*)&result, parms,
  701. RowNum);
  702. return result;
  703. }
  704. void CDataGrid::Scroll(long Cols, long Rows)
  705. {
  706. static BYTE parms[] =
  707. VTS_I4 VTS_I4;
  708. InvokeHelper(0xdc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  709.  Cols, Rows);
  710. }
  711. CSelBookmarks CDataGrid::GetSelBookmarks()
  712. {
  713. LPDISPATCH pDispatch;
  714. InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  715. return CSelBookmarks(pDispatch);
  716. }
  717. short CDataGrid::SplitContaining(float X, float Y)
  718. {
  719. short result;
  720. static BYTE parms[] =
  721. VTS_R4 VTS_R4;
  722. InvokeHelper(0x72, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  723. X, Y);
  724. return result;
  725. }
  726. CSplits CDataGrid::GetSplits()
  727. {
  728. LPDISPATCH pDispatch;
  729. InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  730. return CSplits(pDispatch);
  731. }