msflexgrid.cpp
上传用户:hzwailv
上传日期:2010-01-09
资源大小:405k
文件大小:29k
源码类别:

GIS编程

开发平台:

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 "msflexgrid.h"
  6. // Dispatch interfaces referenced by this interface
  7. #include "Font.h"
  8. #include "Picture.h"
  9. #include "rowcursor.h"
  10. /////////////////////////////////////////////////////////////////////////////
  11. // CMSFlexGrid
  12. IMPLEMENT_DYNCREATE(CMSFlexGrid, CWnd)
  13. /////////////////////////////////////////////////////////////////////////////
  14. // CMSFlexGrid properties
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CMSFlexGrid operations
  17. long CMSFlexGrid::GetRows()
  18. {
  19. long result;
  20. InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  21. return result;
  22. }
  23. void CMSFlexGrid::SetRows(long nNewValue)
  24. {
  25. static BYTE parms[] =
  26. VTS_I4;
  27. InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  28.  nNewValue);
  29. }
  30. long CMSFlexGrid::GetCols()
  31. {
  32. long result;
  33. InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  34. return result;
  35. }
  36. void CMSFlexGrid::SetCols(long nNewValue)
  37. {
  38. static BYTE parms[] =
  39. VTS_I4;
  40. InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  41.  nNewValue);
  42. }
  43. long CMSFlexGrid::GetFixedRows()
  44. {
  45. long result;
  46. InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  47. return result;
  48. }
  49. void CMSFlexGrid::SetFixedRows(long nNewValue)
  50. {
  51. static BYTE parms[] =
  52. VTS_I4;
  53. InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  54.  nNewValue);
  55. }
  56. long CMSFlexGrid::GetFixedCols()
  57. {
  58. long result;
  59. InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  60. return result;
  61. }
  62. void CMSFlexGrid::SetFixedCols(long nNewValue)
  63. {
  64. static BYTE parms[] =
  65. VTS_I4;
  66. InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  67.  nNewValue);
  68. }
  69. short CMSFlexGrid::GetVersion()
  70. {
  71. short result;
  72. InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  73. return result;
  74. }
  75. CString CMSFlexGrid::GetFormatString()
  76. {
  77. CString result;
  78. InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  79. return result;
  80. }
  81. void CMSFlexGrid::SetFormatString(LPCTSTR lpszNewValue)
  82. {
  83. static BYTE parms[] =
  84. VTS_BSTR;
  85. InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  86.  lpszNewValue);
  87. }
  88. long CMSFlexGrid::GetTopRow()
  89. {
  90. long result;
  91. InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  92. return result;
  93. }
  94. void CMSFlexGrid::SetTopRow(long nNewValue)
  95. {
  96. static BYTE parms[] =
  97. VTS_I4;
  98. InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  99.  nNewValue);
  100. }
  101. long CMSFlexGrid::GetLeftCol()
  102. {
  103. long result;
  104. InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  105. return result;
  106. }
  107. void CMSFlexGrid::SetLeftCol(long nNewValue)
  108. {
  109. static BYTE parms[] =
  110. VTS_I4;
  111. InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  112.  nNewValue);
  113. }
  114. long CMSFlexGrid::GetRow()
  115. {
  116. long result;
  117. InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  118. return result;
  119. }
  120. void CMSFlexGrid::SetRow(long nNewValue)
  121. {
  122. static BYTE parms[] =
  123. VTS_I4;
  124. InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  125.  nNewValue);
  126. }
  127. long CMSFlexGrid::GetCol()
  128. {
  129. long result;
  130. InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  131. return result;
  132. }
  133. void CMSFlexGrid::SetCol(long nNewValue)
  134. {
  135. static BYTE parms[] =
  136. VTS_I4;
  137. InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  138.  nNewValue);
  139. }
  140. long CMSFlexGrid::GetRowSel()
  141. {
  142. long result;
  143. InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  144. return result;
  145. }
  146. void CMSFlexGrid::SetRowSel(long nNewValue)
  147. {
  148. static BYTE parms[] =
  149. VTS_I4;
  150. InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  151.  nNewValue);
  152. }
  153. long CMSFlexGrid::GetColSel()
  154. {
  155. long result;
  156. InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  157. return result;
  158. }
  159. void CMSFlexGrid::SetColSel(long nNewValue)
  160. {
  161. static BYTE parms[] =
  162. VTS_I4;
  163. InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  164.  nNewValue);
  165. }
  166. CString CMSFlexGrid::GetText()
  167. {
  168. CString result;
  169. InvokeHelper(0x0, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  170. return result;
  171. }
  172. void CMSFlexGrid::SetText(LPCTSTR lpszNewValue)
  173. {
  174. static BYTE parms[] =
  175. VTS_BSTR;
  176. InvokeHelper(0x0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  177.  lpszNewValue);
  178. }
  179. unsigned long CMSFlexGrid::GetBackColor()
  180. {
  181. unsigned long result;
  182. InvokeHelper(DISPID_BACKCOLOR, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  183. return result;
  184. }
  185. void CMSFlexGrid::SetBackColor(unsigned long newValue)
  186. {
  187. static BYTE parms[] =
  188. VTS_I4;
  189. InvokeHelper(DISPID_BACKCOLOR, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  190.  newValue);
  191. }
  192. unsigned long CMSFlexGrid::GetForeColor()
  193. {
  194. unsigned long result;
  195. InvokeHelper(DISPID_FORECOLOR, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  196. return result;
  197. }
  198. void CMSFlexGrid::SetForeColor(unsigned long newValue)
  199. {
  200. static BYTE parms[] =
  201. VTS_I4;
  202. InvokeHelper(DISPID_FORECOLOR, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  203.  newValue);
  204. }
  205. unsigned long CMSFlexGrid::GetBackColorFixed()
  206. {
  207. unsigned long result;
  208. InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  209. return result;
  210. }
  211. void CMSFlexGrid::SetBackColorFixed(unsigned long newValue)
  212. {
  213. static BYTE parms[] =
  214. VTS_I4;
  215. InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  216.  newValue);
  217. }
  218. unsigned long CMSFlexGrid::GetForeColorFixed()
  219. {
  220. unsigned long result;
  221. InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  222. return result;
  223. }
  224. void CMSFlexGrid::SetForeColorFixed(unsigned long newValue)
  225. {
  226. static BYTE parms[] =
  227. VTS_I4;
  228. InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  229.  newValue);
  230. }
  231. unsigned long CMSFlexGrid::GetBackColorSel()
  232. {
  233. unsigned long result;
  234. InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  235. return result;
  236. }
  237. void CMSFlexGrid::SetBackColorSel(unsigned long newValue)
  238. {
  239. static BYTE parms[] =
  240. VTS_I4;
  241. InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  242.  newValue);
  243. }
  244. unsigned long CMSFlexGrid::GetForeColorSel()
  245. {
  246. unsigned long result;
  247. InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  248. return result;
  249. }
  250. void CMSFlexGrid::SetForeColorSel(unsigned long newValue)
  251. {
  252. static BYTE parms[] =
  253. VTS_I4;
  254. InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  255.  newValue);
  256. }
  257. unsigned long CMSFlexGrid::GetBackColorBkg()
  258. {
  259. unsigned long result;
  260. InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  261. return result;
  262. }
  263. void CMSFlexGrid::SetBackColorBkg(unsigned long newValue)
  264. {
  265. static BYTE parms[] =
  266. VTS_I4;
  267. InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  268.  newValue);
  269. }
  270. BOOL CMSFlexGrid::GetWordWrap()
  271. {
  272. BOOL result;
  273. InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  274. return result;
  275. }
  276. void CMSFlexGrid::SetWordWrap(BOOL bNewValue)
  277. {
  278. static BYTE parms[] =
  279. VTS_BOOL;
  280. InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  281.  bNewValue);
  282. }
  283. COleFont1 CMSFlexGrid::GetFont()
  284. {
  285. LPDISPATCH pDispatch;
  286. InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  287. return COleFont1(pDispatch);
  288. }
  289. void CMSFlexGrid::SetRefFont(LPDISPATCH newValue)
  290. {
  291. static BYTE parms[] =
  292. VTS_DISPATCH;
  293. InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  294.  newValue);
  295. }
  296. float CMSFlexGrid::GetFontWidth()
  297. {
  298. float result;
  299. InvokeHelper(0x54, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  300. return result;
  301. }
  302. void CMSFlexGrid::SetFontWidth(float newValue)
  303. {
  304. static BYTE parms[] =
  305. VTS_R4;
  306. InvokeHelper(0x54, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  307.  newValue);
  308. }
  309. CString CMSFlexGrid::GetCellFontName()
  310. {
  311. CString result;
  312. InvokeHelper(0x4d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  313. return result;
  314. }
  315. void CMSFlexGrid::SetCellFontName(LPCTSTR lpszNewValue)
  316. {
  317. static BYTE parms[] =
  318. VTS_BSTR;
  319. InvokeHelper(0x4d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  320.  lpszNewValue);
  321. }
  322. float CMSFlexGrid::GetCellFontSize()
  323. {
  324. float result;
  325. InvokeHelper(0x4e, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  326. return result;
  327. }
  328. void CMSFlexGrid::SetCellFontSize(float newValue)
  329. {
  330. static BYTE parms[] =
  331. VTS_R4;
  332. InvokeHelper(0x4e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  333.  newValue);
  334. }
  335. BOOL CMSFlexGrid::GetCellFontBold()
  336. {
  337. BOOL result;
  338. InvokeHelper(0x4f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  339. return result;
  340. }
  341. void CMSFlexGrid::SetCellFontBold(BOOL bNewValue)
  342. {
  343. static BYTE parms[] =
  344. VTS_BOOL;
  345. InvokeHelper(0x4f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  346.  bNewValue);
  347. }
  348. BOOL CMSFlexGrid::GetCellFontItalic()
  349. {
  350. BOOL result;
  351. InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  352. return result;
  353. }
  354. void CMSFlexGrid::SetCellFontItalic(BOOL bNewValue)
  355. {
  356. static BYTE parms[] =
  357. VTS_BOOL;
  358. InvokeHelper(0x50, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  359.  bNewValue);
  360. }
  361. BOOL CMSFlexGrid::GetCellFontUnderline()
  362. {
  363. BOOL result;
  364. InvokeHelper(0x51, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  365. return result;
  366. }
  367. void CMSFlexGrid::SetCellFontUnderline(BOOL bNewValue)
  368. {
  369. static BYTE parms[] =
  370. VTS_BOOL;
  371. InvokeHelper(0x51, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  372.  bNewValue);
  373. }
  374. BOOL CMSFlexGrid::GetCellFontStrikeThrough()
  375. {
  376. BOOL result;
  377. InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  378. return result;
  379. }
  380. void CMSFlexGrid::SetCellFontStrikeThrough(BOOL bNewValue)
  381. {
  382. static BYTE parms[] =
  383. VTS_BOOL;
  384. InvokeHelper(0x52, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  385.  bNewValue);
  386. }
  387. float CMSFlexGrid::GetCellFontWidth()
  388. {
  389. float result;
  390. InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  391. return result;
  392. }
  393. void CMSFlexGrid::SetCellFontWidth(float newValue)
  394. {
  395. static BYTE parms[] =
  396. VTS_R4;
  397. InvokeHelper(0x53, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  398.  newValue);
  399. }
  400. long CMSFlexGrid::GetTextStyle()
  401. {
  402. long result;
  403. InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  404. return result;
  405. }
  406. void CMSFlexGrid::SetTextStyle(long nNewValue)
  407. {
  408. static BYTE parms[] =
  409. VTS_I4;
  410. InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  411.  nNewValue);
  412. }
  413. long CMSFlexGrid::GetTextStyleFixed()
  414. {
  415. long result;
  416. InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  417. return result;
  418. }
  419. void CMSFlexGrid::SetTextStyleFixed(long nNewValue)
  420. {
  421. static BYTE parms[] =
  422. VTS_I4;
  423. InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  424.  nNewValue);
  425. }
  426. BOOL CMSFlexGrid::GetScrollTrack()
  427. {
  428. BOOL result;
  429. InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  430. return result;
  431. }
  432. void CMSFlexGrid::SetScrollTrack(BOOL bNewValue)
  433. {
  434. static BYTE parms[] =
  435. VTS_BOOL;
  436. InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  437.  bNewValue);
  438. }
  439. long CMSFlexGrid::GetFocusRect()
  440. {
  441. long result;
  442. InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  443. return result;
  444. }
  445. void CMSFlexGrid::SetFocusRect(long nNewValue)
  446. {
  447. static BYTE parms[] =
  448. VTS_I4;
  449. InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  450.  nNewValue);
  451. }
  452. long CMSFlexGrid::GetHighLight()
  453. {
  454. long result;
  455. InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  456. return result;
  457. }
  458. void CMSFlexGrid::SetHighLight(long nNewValue)
  459. {
  460. static BYTE parms[] =
  461. VTS_I4;
  462. InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  463.  nNewValue);
  464. }
  465. BOOL CMSFlexGrid::GetRedraw()
  466. {
  467. BOOL result;
  468. InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  469. return result;
  470. }
  471. void CMSFlexGrid::SetRedraw(BOOL bNewValue)
  472. {
  473. static BYTE parms[] =
  474. VTS_BOOL;
  475. InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  476.  bNewValue);
  477. }
  478. long CMSFlexGrid::GetScrollBars()
  479. {
  480. long result;
  481. InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  482. return result;
  483. }
  484. void CMSFlexGrid::SetScrollBars(long nNewValue)
  485. {
  486. static BYTE parms[] =
  487. VTS_I4;
  488. InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  489.  nNewValue);
  490. }
  491. long CMSFlexGrid::GetMouseRow()
  492. {
  493. long result;
  494. InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  495. return result;
  496. }
  497. long CMSFlexGrid::GetMouseCol()
  498. {
  499. long result;
  500. InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  501. return result;
  502. }
  503. long CMSFlexGrid::GetCellLeft()
  504. {
  505. long result;
  506. InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  507. return result;
  508. }
  509. long CMSFlexGrid::GetCellTop()
  510. {
  511. long result;
  512. InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  513. return result;
  514. }
  515. long CMSFlexGrid::GetCellWidth()
  516. {
  517. long result;
  518. InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  519. return result;
  520. }
  521. long CMSFlexGrid::GetCellHeight()
  522. {
  523. long result;
  524. InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  525. return result;
  526. }
  527. long CMSFlexGrid::GetRowHeightMin()
  528. {
  529. long result;
  530. InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  531. return result;
  532. }
  533. void CMSFlexGrid::SetRowHeightMin(long nNewValue)
  534. {
  535. static BYTE parms[] =
  536. VTS_I4;
  537. InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  538.  nNewValue);
  539. }
  540. long CMSFlexGrid::GetFillStyle()
  541. {
  542. long result;
  543. InvokeHelper(0xfffffe01, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  544. return result;
  545. }
  546. void CMSFlexGrid::SetFillStyle(long nNewValue)
  547. {
  548. static BYTE parms[] =
  549. VTS_I4;
  550. InvokeHelper(0xfffffe01, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  551.  nNewValue);
  552. }
  553. long CMSFlexGrid::GetGridLines()
  554. {
  555. long result;
  556. InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  557. return result;
  558. }
  559. void CMSFlexGrid::SetGridLines(long nNewValue)
  560. {
  561. static BYTE parms[] =
  562. VTS_I4;
  563. InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  564.  nNewValue);
  565. }
  566. long CMSFlexGrid::GetGridLinesFixed()
  567. {
  568. long result;
  569. InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  570. return result;
  571. }
  572. void CMSFlexGrid::SetGridLinesFixed(long nNewValue)
  573. {
  574. static BYTE parms[] =
  575. VTS_I4;
  576. InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  577.  nNewValue);
  578. }
  579. unsigned long CMSFlexGrid::GetGridColor()
  580. {
  581. unsigned long result;
  582. InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  583. return result;
  584. }
  585. void CMSFlexGrid::SetGridColor(unsigned long newValue)
  586. {
  587. static BYTE parms[] =
  588. VTS_I4;
  589. InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  590.  newValue);
  591. }
  592. unsigned long CMSFlexGrid::GetGridColorFixed()
  593. {
  594. unsigned long result;
  595. InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  596. return result;
  597. }
  598. void CMSFlexGrid::SetGridColorFixed(unsigned long newValue)
  599. {
  600. static BYTE parms[] =
  601. VTS_I4;
  602. InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  603.  newValue);
  604. }
  605. unsigned long CMSFlexGrid::GetCellBackColor()
  606. {
  607. unsigned long result;
  608. InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  609. return result;
  610. }
  611. void CMSFlexGrid::SetCellBackColor(unsigned long newValue)
  612. {
  613. static BYTE parms[] =
  614. VTS_I4;
  615. InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  616.  newValue);
  617. }
  618. unsigned long CMSFlexGrid::GetCellForeColor()
  619. {
  620. unsigned long result;
  621. InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  622. return result;
  623. }
  624. void CMSFlexGrid::SetCellForeColor(unsigned long newValue)
  625. {
  626. static BYTE parms[] =
  627. VTS_I4;
  628. InvokeHelper(0x27, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  629.  newValue);
  630. }
  631. short CMSFlexGrid::GetCellAlignment()
  632. {
  633. short result;
  634. InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  635. return result;
  636. }
  637. void CMSFlexGrid::SetCellAlignment(short nNewValue)
  638. {
  639. static BYTE parms[] =
  640. VTS_I2;
  641. InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  642.  nNewValue);
  643. }
  644. long CMSFlexGrid::GetCellTextStyle()
  645. {
  646. long result;
  647. InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  648. return result;
  649. }
  650. void CMSFlexGrid::SetCellTextStyle(long nNewValue)
  651. {
  652. static BYTE parms[] =
  653. VTS_I4;
  654. InvokeHelper(0x29, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  655.  nNewValue);
  656. }
  657. short CMSFlexGrid::GetCellPictureAlignment()
  658. {
  659. short result;
  660. InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  661. return result;
  662. }
  663. void CMSFlexGrid::SetCellPictureAlignment(short nNewValue)
  664. {
  665. static BYTE parms[] =
  666. VTS_I2;
  667. InvokeHelper(0x2b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  668.  nNewValue);
  669. }
  670. CString CMSFlexGrid::GetClip()
  671. {
  672. CString result;
  673. InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  674. return result;
  675. }
  676. void CMSFlexGrid::SetClip(LPCTSTR lpszNewValue)
  677. {
  678. static BYTE parms[] =
  679. VTS_BSTR;
  680. InvokeHelper(0x2d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  681.  lpszNewValue);
  682. }
  683. void CMSFlexGrid::SetSort(short nNewValue)
  684. {
  685. static BYTE parms[] =
  686. VTS_I2;
  687. InvokeHelper(0x2e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  688.  nNewValue);
  689. }
  690. long CMSFlexGrid::GetSelectionMode()
  691. {
  692. long result;
  693. InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  694. return result;
  695. }
  696. void CMSFlexGrid::SetSelectionMode(long nNewValue)
  697. {
  698. static BYTE parms[] =
  699. VTS_I4;
  700. InvokeHelper(0x2f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  701.  nNewValue);
  702. }
  703. long CMSFlexGrid::GetMergeCells()
  704. {
  705. long result;
  706. InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  707. return result;
  708. }
  709. void CMSFlexGrid::SetMergeCells(long nNewValue)
  710. {
  711. static BYTE parms[] =
  712. VTS_I4;
  713. InvokeHelper(0x30, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  714.  nNewValue);
  715. }
  716. BOOL CMSFlexGrid::GetAllowBigSelection()
  717. {
  718. BOOL result;
  719. InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  720. return result;
  721. }
  722. void CMSFlexGrid::SetAllowBigSelection(BOOL bNewValue)
  723. {
  724. static BYTE parms[] =
  725. VTS_BOOL;
  726. InvokeHelper(0x33, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  727.  bNewValue);
  728. }
  729. long CMSFlexGrid::GetAllowUserResizing()
  730. {
  731. long result;
  732. InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  733. return result;
  734. }
  735. void CMSFlexGrid::SetAllowUserResizing(long nNewValue)
  736. {
  737. static BYTE parms[] =
  738. VTS_I4;
  739. InvokeHelper(0x34, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  740.  nNewValue);
  741. }
  742. long CMSFlexGrid::GetBorderStyle()
  743. {
  744. long result;
  745. InvokeHelper(DISPID_BORDERSTYLE, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  746. return result;
  747. }
  748. void CMSFlexGrid::SetBorderStyle(long nNewValue)
  749. {
  750. static BYTE parms[] =
  751. VTS_I4;
  752. InvokeHelper(DISPID_BORDERSTYLE, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  753.  nNewValue);
  754. }
  755. long CMSFlexGrid::GetHWnd()
  756. {
  757. long result;
  758. InvokeHelper(DISPID_HWND, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  759. return result;
  760. }
  761. BOOL CMSFlexGrid::GetEnabled()
  762. {
  763. BOOL result;
  764. InvokeHelper(DISPID_ENABLED, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  765. return result;
  766. }
  767. void CMSFlexGrid::SetEnabled(BOOL bNewValue)
  768. {
  769. static BYTE parms[] =
  770. VTS_BOOL;
  771. InvokeHelper(DISPID_ENABLED, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  772.  bNewValue);
  773. }
  774. long CMSFlexGrid::GetAppearance()
  775. {
  776. long result;
  777. InvokeHelper(DISPID_APPEARANCE, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  778. return result;
  779. }
  780. void CMSFlexGrid::SetAppearance(long nNewValue)
  781. {
  782. static BYTE parms[] =
  783. VTS_I4;
  784. InvokeHelper(DISPID_APPEARANCE, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  785.  nNewValue);
  786. }
  787. long CMSFlexGrid::GetMousePointer()
  788. {
  789. long result;
  790. InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  791. return result;
  792. }
  793. void CMSFlexGrid::SetMousePointer(long nNewValue)
  794. {
  795. static BYTE parms[] =
  796. VTS_I4;
  797. InvokeHelper(0x35, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  798.  nNewValue);
  799. }
  800. CPicture CMSFlexGrid::GetMouseIcon()
  801. {
  802. LPDISPATCH pDispatch;
  803. InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  804. return CPicture(pDispatch);
  805. }
  806. void CMSFlexGrid::SetRefMouseIcon(LPDISPATCH newValue)
  807. {
  808. static BYTE parms[] =
  809. VTS_DISPATCH;
  810. InvokeHelper(0x36, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  811.  newValue);
  812. }
  813. long CMSFlexGrid::GetPictureType()
  814. {
  815. long result;
  816. InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  817. return result;
  818. }
  819. void CMSFlexGrid::SetPictureType(long nNewValue)
  820. {
  821. static BYTE parms[] =
  822. VTS_I4;
  823. InvokeHelper(0x32, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  824.  nNewValue);
  825. }
  826. CPicture CMSFlexGrid::GetPicture()
  827. {
  828. LPDISPATCH pDispatch;
  829. InvokeHelper(0x31, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  830. return CPicture(pDispatch);
  831. }
  832. CPicture CMSFlexGrid::GetCellPicture()
  833. {
  834. LPDISPATCH pDispatch;
  835. InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  836. return CPicture(pDispatch);
  837. }
  838. void CMSFlexGrid::SetRefCellPicture(LPDISPATCH newValue)
  839. {
  840. static BYTE parms[] =
  841. VTS_DISPATCH;
  842. InvokeHelper(0x2a, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  843.  newValue);
  844. }
  845. CString CMSFlexGrid::GetTextArray(long index)
  846. {
  847. CString result;
  848. static BYTE parms[] =
  849. VTS_I4;
  850. InvokeHelper(0x37, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  851. index);
  852. return result;
  853. }
  854. void CMSFlexGrid::SetTextArray(long index, LPCTSTR lpszNewValue)
  855. {
  856. static BYTE parms[] =
  857. VTS_I4 VTS_BSTR;
  858. InvokeHelper(0x37, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  859.  index, lpszNewValue);
  860. }
  861. short CMSFlexGrid::GetColAlignment(long index)
  862. {
  863. short result;
  864. static BYTE parms[] =
  865. VTS_I4;
  866. InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, parms,
  867. index);
  868. return result;
  869. }
  870. void CMSFlexGrid::SetColAlignment(long index, short nNewValue)
  871. {
  872. static BYTE parms[] =
  873. VTS_I4 VTS_I2;
  874. InvokeHelper(0x38, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  875.  index, nNewValue);
  876. }
  877. long CMSFlexGrid::GetColWidth(long index)
  878. {
  879. long result;
  880. static BYTE parms[] =
  881. VTS_I4;
  882. InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  883. index);
  884. return result;
  885. }
  886. void CMSFlexGrid::SetColWidth(long index, long nNewValue)
  887. {
  888. static BYTE parms[] =
  889. VTS_I4 VTS_I4;
  890. InvokeHelper(0x39, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  891.  index, nNewValue);
  892. }
  893. long CMSFlexGrid::GetRowHeight(long index)
  894. {
  895. long result;
  896. static BYTE parms[] =
  897. VTS_I4;
  898. InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  899. index);
  900. return result;
  901. }
  902. void CMSFlexGrid::SetRowHeight(long index, long nNewValue)
  903. {
  904. static BYTE parms[] =
  905. VTS_I4 VTS_I4;
  906. InvokeHelper(0x3a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  907.  index, nNewValue);
  908. }
  909. BOOL CMSFlexGrid::GetMergeRow(long index)
  910. {
  911. BOOL result;
  912. static BYTE parms[] =
  913. VTS_I4;
  914. InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  915. index);
  916. return result;
  917. }
  918. void CMSFlexGrid::SetMergeRow(long index, BOOL bNewValue)
  919. {
  920. static BYTE parms[] =
  921. VTS_I4 VTS_BOOL;
  922. InvokeHelper(0x3b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  923.  index, bNewValue);
  924. }
  925. BOOL CMSFlexGrid::GetMergeCol(long index)
  926. {
  927. BOOL result;
  928. static BYTE parms[] =
  929. VTS_I4;
  930. InvokeHelper(0x3c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  931. index);
  932. return result;
  933. }
  934. void CMSFlexGrid::SetMergeCol(long index, BOOL bNewValue)
  935. {
  936. static BYTE parms[] =
  937. VTS_I4 VTS_BOOL;
  938. InvokeHelper(0x3c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  939.  index, bNewValue);
  940. }
  941. void CMSFlexGrid::SetRowPosition(long index, long nNewValue)
  942. {
  943. static BYTE parms[] =
  944. VTS_I4 VTS_I4;
  945. InvokeHelper(0x3d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  946.  index, nNewValue);
  947. }
  948. void CMSFlexGrid::SetColPosition(long index, long nNewValue)
  949. {
  950. static BYTE parms[] =
  951. VTS_I4 VTS_I4;
  952. InvokeHelper(0x3e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  953.  index, nNewValue);
  954. }
  955. long CMSFlexGrid::GetRowData(long index)
  956. {
  957. long result;
  958. static BYTE parms[] =
  959. VTS_I4;
  960. InvokeHelper(0x3f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  961. index);
  962. return result;
  963. }
  964. void CMSFlexGrid::SetRowData(long index, long nNewValue)
  965. {
  966. static BYTE parms[] =
  967. VTS_I4 VTS_I4;
  968. InvokeHelper(0x3f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  969.  index, nNewValue);
  970. }
  971. long CMSFlexGrid::GetColData(long index)
  972. {
  973. long result;
  974. static BYTE parms[] =
  975. VTS_I4;
  976. InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  977. index);
  978. return result;
  979. }
  980. void CMSFlexGrid::SetColData(long index, long nNewValue)
  981. {
  982. static BYTE parms[] =
  983. VTS_I4 VTS_I4;
  984. InvokeHelper(0x40, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  985.  index, nNewValue);
  986. }
  987. CString CMSFlexGrid::GetTextMatrix(long Row, long Col)
  988. {
  989. CString result;
  990. static BYTE parms[] =
  991. VTS_I4 VTS_I4;
  992. InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  993. Row, Col);
  994. return result;
  995. }
  996. void CMSFlexGrid::SetTextMatrix(long Row, long Col, LPCTSTR lpszNewValue)
  997. {
  998. static BYTE parms[] =
  999. VTS_I4 VTS_I4 VTS_BSTR;
  1000. InvokeHelper(0x41, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1001.  Row, Col, lpszNewValue);
  1002. }
  1003. void CMSFlexGrid::AddItem(LPCTSTR Item, const VARIANT& index)
  1004. {
  1005. static BYTE parms[] =
  1006. VTS_BSTR VTS_VARIANT;
  1007. InvokeHelper(0x42, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1008.  Item, &index);
  1009. }
  1010. void CMSFlexGrid::RemoveItem(long index)
  1011. {
  1012. static BYTE parms[] =
  1013. VTS_I4;
  1014. InvokeHelper(0x43, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1015.  index);
  1016. }
  1017. void CMSFlexGrid::Clear()
  1018. {
  1019. InvokeHelper(0x44, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1020. }
  1021. void CMSFlexGrid::Refresh()
  1022. {
  1023. InvokeHelper(DISPID_REFRESH, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1024. }
  1025. CRowCursor CMSFlexGrid::GetDataSource()
  1026. {
  1027. LPDISPATCH pDispatch;
  1028. InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  1029. return CRowCursor(pDispatch);
  1030. }
  1031. void CMSFlexGrid::SetDataSource(LPDISPATCH newValue)
  1032. {
  1033. static BYTE parms[] =
  1034. VTS_DISPATCH;
  1035. InvokeHelper(0x4c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1036.  newValue);
  1037. }
  1038. BOOL CMSFlexGrid::GetRowIsVisible(long index)
  1039. {
  1040. BOOL result;
  1041. static BYTE parms[] =
  1042. VTS_I4;
  1043. InvokeHelper(0x55, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1044. index);
  1045. return result;
  1046. }
  1047. BOOL CMSFlexGrid::GetColIsVisible(long index)
  1048. {
  1049. BOOL result;
  1050. static BYTE parms[] =
  1051. VTS_I4;
  1052. InvokeHelper(0x56, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1053. index);
  1054. return result;
  1055. }
  1056. long CMSFlexGrid::GetRowPos(long index)
  1057. {
  1058. long result;
  1059. static BYTE parms[] =
  1060. VTS_I4;
  1061. InvokeHelper(0x57, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1062. index);
  1063. return result;
  1064. }
  1065. long CMSFlexGrid::GetColPos(long index)
  1066. {
  1067. long result;
  1068. static BYTE parms[] =
  1069. VTS_I4;
  1070. InvokeHelper(0x58, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1071. index);
  1072. return result;
  1073. }
  1074. short CMSFlexGrid::GetGridLineWidth()
  1075. {
  1076. short result;
  1077. InvokeHelper(0x59, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  1078. return result;
  1079. }
  1080. void CMSFlexGrid::SetGridLineWidth(short nNewValue)
  1081. {
  1082. static BYTE parms[] =
  1083. VTS_I2;
  1084. InvokeHelper(0x59, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1085.  nNewValue);
  1086. }
  1087. short CMSFlexGrid::GetFixedAlignment(long index)
  1088. {
  1089. short result;
  1090. static BYTE parms[] =
  1091. VTS_I4;
  1092. InvokeHelper(0x5a, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, parms,
  1093. index);
  1094. return result;
  1095. }
  1096. void CMSFlexGrid::SetFixedAlignment(long index, short nNewValue)
  1097. {
  1098. static BYTE parms[] =
  1099. VTS_I4 VTS_I2;
  1100. InvokeHelper(0x5a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1101.  index, nNewValue);
  1102. }
  1103. BOOL CMSFlexGrid::GetRightToLeft()
  1104. {
  1105. BOOL result;
  1106. InvokeHelper(0xfffffd9d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  1107. return result;
  1108. }
  1109. void CMSFlexGrid::SetRightToLeft(BOOL bNewValue)
  1110. {
  1111. static BYTE parms[] =
  1112. VTS_BOOL;
  1113. InvokeHelper(0xfffffd9d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1114.  bNewValue);
  1115. }
  1116. long CMSFlexGrid::GetOLEDropMode()
  1117. {
  1118. long result;
  1119. InvokeHelper(0x60f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  1120. return result;
  1121. }
  1122. void CMSFlexGrid::SetOLEDropMode(long nNewValue)
  1123. {
  1124. static BYTE parms[] =
  1125. VTS_I4;
  1126. InvokeHelper(0x60f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1127.  nNewValue);
  1128. }
  1129. void CMSFlexGrid::OLEDrag()
  1130. {
  1131. InvokeHelper(0x610, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1132. }