datagrid.cpp
上传用户:biney012
上传日期:2022-05-09
资源大小:4592k
文件大小:19k
源码类别:

数据库系统

开发平台:

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