msflexgrid.cpp
上传用户:oy0519
上传日期:2008-01-20
资源大小:124k
文件大小:28k
源码类别:

绘图程序

开发平台:

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