home *** CD-ROM | disk | FTP | other *** search
/ Delphi 5 for Professionals / DELPHI5.iso / AddOns / Components / RealTime Graphics ActiveX / DATA.3 / Examples / CPP / Simple / scrollx.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-12-29  |  51.1 KB  |  2,317 lines
  1. // Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
  2.  
  3. // NOTE: Do not modify the contents of this file.  If this class is regenerated by
  4. //  Microsoft Visual C++, your modifications will be overwritten.
  5.  
  6.  
  7. #include "stdafx.h"
  8. #include "scrollx.h"
  9.  
  10. /////////////////////////////////////////////////////////////////////////////
  11. // CScrollX
  12.  
  13. IMPLEMENT_DYNCREATE(CScrollX, CWnd)
  14.  
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CScrollX properties
  17.  
  18. long CScrollX::GetPlotBackgroundColor()
  19. {
  20.     long result;
  21.     GetProperty(0x1, VT_I4, (void*)&result);
  22.     return result;
  23. }
  24.  
  25. void CScrollX::SetPlotBackgroundColor(long propVal)
  26. {
  27.     SetProperty(0x1, VT_I4, propVal);
  28. }
  29.  
  30. double CScrollX::GetLeftPlotArea()
  31. {
  32.     double result;
  33.     GetProperty(0x2, VT_R8, (void*)&result);
  34.     return result;
  35. }
  36.  
  37. void CScrollX::SetLeftPlotArea(double propVal)
  38. {
  39.     SetProperty(0x2, VT_R8, propVal);
  40. }
  41.  
  42. double CScrollX::GetRightPlotArea()
  43. {
  44.     double result;
  45.     GetProperty(0x3, VT_R8, (void*)&result);
  46.     return result;
  47. }
  48.  
  49. void CScrollX::SetRightPlotArea(double propVal)
  50. {
  51.     SetProperty(0x3, VT_R8, propVal);
  52. }
  53.  
  54. long CScrollX::GetMajorTickSize()
  55. {
  56.     long result;
  57.     GetProperty(0x4, VT_I4, (void*)&result);
  58.     return result;
  59. }
  60.  
  61. void CScrollX::SetMajorTickSize(long propVal)
  62. {
  63.     SetProperty(0x4, VT_I4, propVal);
  64. }
  65.  
  66. long CScrollX::GetMinorTickSize()
  67. {
  68.     long result;
  69.     GetProperty(0x5, VT_I4, (void*)&result);
  70.     return result;
  71. }
  72.  
  73. void CScrollX::SetMinorTickSize(long propVal)
  74. {
  75.     SetProperty(0x5, VT_I4, propVal);
  76. }
  77.  
  78. double CScrollX::GetBottomPlotArea()
  79. {
  80.     double result;
  81.     GetProperty(0x6, VT_R8, (void*)&result);
  82.     return result;
  83. }
  84.  
  85. void CScrollX::SetBottomPlotArea(double propVal)
  86. {
  87.     SetProperty(0x6, VT_R8, propVal);
  88. }
  89.  
  90. double CScrollX::GetTopPlotArea()
  91. {
  92.     double result;
  93.     GetProperty(0x7, VT_R8, (void*)&result);
  94.     return result;
  95. }
  96.  
  97. void CScrollX::SetTopPlotArea(double propVal)
  98. {
  99.     SetProperty(0x7, VT_R8, propVal);
  100. }
  101.  
  102. long CScrollX::GetCurrentPlot()
  103. {
  104.     long result;
  105.     GetProperty(0x27, VT_I4, (void*)&result);
  106.     return result;
  107. }
  108.  
  109. void CScrollX::SetCurrentPlot(long propVal)
  110. {
  111.     SetProperty(0x27, VT_I4, propVal);
  112. }
  113.  
  114. long CScrollX::GetCurrentAxis()
  115. {
  116.     long result;
  117.     GetProperty(0x28, VT_I4, (void*)&result);
  118.     return result;
  119. }
  120.  
  121. void CScrollX::SetCurrentAxis(long propVal)
  122. {
  123.     SetProperty(0x28, VT_I4, propVal);
  124. }
  125.  
  126. long CScrollX::GetWindowBorderColor()
  127. {
  128.     long result;
  129.     GetProperty(0x8, VT_I4, (void*)&result);
  130.     return result;
  131. }
  132.  
  133. void CScrollX::SetWindowBorderColor(long propVal)
  134. {
  135.     SetProperty(0x8, VT_I4, propVal);
  136. }
  137.  
  138. long CScrollX::GetWindowBackgroundColor()
  139. {
  140.     long result;
  141.     GetProperty(0x9, VT_I4, (void*)&result);
  142.     return result;
  143. }
  144.  
  145. void CScrollX::SetWindowBackgroundColor(long propVal)
  146. {
  147.     SetProperty(0x9, VT_I4, propVal);
  148. }
  149.  
  150. long CScrollX::GetWindowBorderStyle()
  151. {
  152.     long result;
  153.     GetProperty(0xa, VT_I4, (void*)&result);
  154.     return result;
  155. }
  156.  
  157. void CScrollX::SetWindowBorderStyle(long propVal)
  158. {
  159.     SetProperty(0xa, VT_I4, propVal);
  160. }
  161.  
  162. long CScrollX::GetWindowBorderThickness()
  163. {
  164.     long result;
  165.     GetProperty(0xb, VT_I4, (void*)&result);
  166.     return result;
  167. }
  168.  
  169. void CScrollX::SetWindowBorderThickness(long propVal)
  170. {
  171.     SetProperty(0xb, VT_I4, propVal);
  172. }
  173.  
  174. long CScrollX::GetWindowResizeMode()
  175. {
  176.     long result;
  177.     GetProperty(0xc, VT_I4, (void*)&result);
  178.     return result;
  179. }
  180.  
  181. void CScrollX::SetWindowResizeMode(long propVal)
  182. {
  183.     SetProperty(0xc, VT_I4, propVal);
  184. }
  185.  
  186. long CScrollX::GetPrintStyle()
  187. {
  188.     long result;
  189.     GetProperty(0xd, VT_I4, (void*)&result);
  190.     return result;
  191. }
  192.  
  193. void CScrollX::SetPrintStyle(long propVal)
  194. {
  195.     SetProperty(0xd, VT_I4, propVal);
  196. }
  197.  
  198. BOOL CScrollX::GetPrintBorder()
  199. {
  200.     BOOL result;
  201.     GetProperty(0xe, VT_BOOL, (void*)&result);
  202.     return result;
  203. }
  204.  
  205. void CScrollX::SetPrintBorder(BOOL propVal)
  206. {
  207.     SetProperty(0xe, VT_BOOL, propVal);
  208. }
  209.  
  210. BOOL CScrollX::GetPrintMaintainAspectRatio()
  211. {
  212.     BOOL result;
  213.     GetProperty(0xf, VT_BOOL, (void*)&result);
  214.     return result;
  215. }
  216.  
  217. void CScrollX::SetPrintMaintainAspectRatio(BOOL propVal)
  218. {
  219.     SetProperty(0xf, VT_BOOL, propVal);
  220. }
  221.  
  222. BOOL CScrollX::GetPrintPlotBackground()
  223. {
  224.     BOOL result;
  225.     GetProperty(0x10, VT_BOOL, (void*)&result);
  226.     return result;
  227. }
  228.  
  229. void CScrollX::SetPrintPlotBackground(BOOL propVal)
  230. {
  231.     SetProperty(0x10, VT_BOOL, propVal);
  232. }
  233.  
  234. BOOL CScrollX::GetPrintGraphBackground()
  235. {
  236.     BOOL result;
  237.     GetProperty(0x11, VT_BOOL, (void*)&result);
  238.     return result;
  239. }
  240.  
  241. void CScrollX::SetPrintGraphBackground(BOOL propVal)
  242. {
  243.     SetProperty(0x11, VT_BOOL, propVal);
  244. }
  245.  
  246. double CScrollX::GetPrintLeft()
  247. {
  248.     double result;
  249.     GetProperty(0x12, VT_R8, (void*)&result);
  250.     return result;
  251. }
  252.  
  253. void CScrollX::SetPrintLeft(double propVal)
  254. {
  255.     SetProperty(0x12, VT_R8, propVal);
  256. }
  257.  
  258. double CScrollX::GetPrintBottom()
  259. {
  260.     double result;
  261.     GetProperty(0x13, VT_R8, (void*)&result);
  262.     return result;
  263. }
  264.  
  265. void CScrollX::SetPrintBottom(double propVal)
  266. {
  267.     SetProperty(0x13, VT_R8, propVal);
  268. }
  269.  
  270. double CScrollX::GetPrintRight()
  271. {
  272.     double result;
  273.     GetProperty(0x14, VT_R8, (void*)&result);
  274.     return result;
  275. }
  276.  
  277. void CScrollX::SetPrintRight(double propVal)
  278. {
  279.     SetProperty(0x14, VT_R8, propVal);
  280. }
  281.  
  282. double CScrollX::GetPrintTop()
  283. {
  284.     double result;
  285.     GetProperty(0x15, VT_R8, (void*)&result);
  286.     return result;
  287. }
  288.  
  289. void CScrollX::SetPrintTop(double propVal)
  290. {
  291.     SetProperty(0x15, VT_R8, propVal);
  292. }
  293.  
  294. long CScrollX::GetSLegendType()
  295. {
  296.     long result;
  297.     GetProperty(0x16, VT_I4, (void*)&result);
  298.     return result;
  299. }
  300.  
  301. void CScrollX::SetSLegendType(long propVal)
  302. {
  303.     SetProperty(0x16, VT_I4, propVal);
  304. }
  305.  
  306. double CScrollX::GetSLegendTop()
  307. {
  308.     double result;
  309.     GetProperty(0x17, VT_R8, (void*)&result);
  310.     return result;
  311. }
  312.  
  313. void CScrollX::SetSLegendTop(double propVal)
  314. {
  315.     SetProperty(0x17, VT_R8, propVal);
  316. }
  317.  
  318. double CScrollX::GetSLegendBottom()
  319. {
  320.     double result;
  321.     GetProperty(0x18, VT_R8, (void*)&result);
  322.     return result;
  323. }
  324.  
  325. void CScrollX::SetSLegendBottom(double propVal)
  326. {
  327.     SetProperty(0x18, VT_R8, propVal);
  328. }
  329.  
  330. double CScrollX::GetSLegendLeft()
  331. {
  332.     double result;
  333.     GetProperty(0x19, VT_R8, (void*)&result);
  334.     return result;
  335. }
  336.  
  337. void CScrollX::SetSLegendLeft(double propVal)
  338. {
  339.     SetProperty(0x19, VT_R8, propVal);
  340. }
  341.  
  342. double CScrollX::GetSLegendRight()
  343. {
  344.     double result;
  345.     GetProperty(0x1a, VT_R8, (void*)&result);
  346.     return result;
  347. }
  348.  
  349. void CScrollX::SetSLegendRight(double propVal)
  350. {
  351.     SetProperty(0x1a, VT_R8, propVal);
  352. }
  353.  
  354. long CScrollX::GetSLegendBackgroundColor()
  355. {
  356.     long result;
  357.     GetProperty(0x1b, VT_I4, (void*)&result);
  358.     return result;
  359. }
  360.  
  361. void CScrollX::SetSLegendBackgroundColor(long propVal)
  362. {
  363.     SetProperty(0x1b, VT_I4, propVal);
  364. }
  365.  
  366. long CScrollX::GetSLegendBorderColor()
  367. {
  368.     long result;
  369.     GetProperty(0x1c, VT_I4, (void*)&result);
  370.     return result;
  371. }
  372.  
  373. void CScrollX::SetSLegendBorderColor(long propVal)
  374. {
  375.     SetProperty(0x1c, VT_I4, propVal);
  376. }
  377.  
  378. long CScrollX::GetSLegendBorderThickness()
  379. {
  380.     long result;
  381.     GetProperty(0x1d, VT_I4, (void*)&result);
  382.     return result;
  383. }
  384.  
  385. void CScrollX::SetSLegendBorderThickness(long propVal)
  386. {
  387.     SetProperty(0x1d, VT_I4, propVal);
  388. }
  389.  
  390. CString CScrollX::GetSLegendFont()
  391. {
  392.     CString result;
  393.     GetProperty(0x1e, VT_BSTR, (void*)&result);
  394.     return result;
  395. }
  396.  
  397. void CScrollX::SetSLegendFont(LPCTSTR propVal)
  398. {
  399.     SetProperty(0x1e, VT_BSTR, propVal);
  400. }
  401.  
  402. long CScrollX::GetSLegendFontStyle()
  403. {
  404.     long result;
  405.     GetProperty(0x1f, VT_I4, (void*)&result);
  406.     return result;
  407. }
  408.  
  409. void CScrollX::SetSLegendFontStyle(long propVal)
  410. {
  411.     SetProperty(0x1f, VT_I4, propVal);
  412. }
  413.  
  414. long CScrollX::GetSLegendFontColor()
  415. {
  416.     long result;
  417.     GetProperty(0x20, VT_I4, (void*)&result);
  418.     return result;
  419. }
  420.  
  421. void CScrollX::SetSLegendFontColor(long propVal)
  422. {
  423.     SetProperty(0x20, VT_I4, propVal);
  424. }
  425.  
  426. BOOL CScrollX::GetSLegendEnable()
  427. {
  428.     BOOL result;
  429.     GetProperty(0x21, VT_BOOL, (void*)&result);
  430.     return result;
  431. }
  432.  
  433. void CScrollX::SetSLegendEnable(BOOL propVal)
  434. {
  435.     SetProperty(0x21, VT_BOOL, propVal);
  436. }
  437.  
  438. CString CScrollX::GetSLegendStrings()
  439. {
  440.     CString result;
  441.     GetProperty(0x22, VT_BSTR, (void*)&result);
  442.     return result;
  443. }
  444.  
  445. void CScrollX::SetSLegendStrings(LPCTSTR propVal)
  446. {
  447.     SetProperty(0x22, VT_BSTR, propVal);
  448. }
  449.  
  450. long CScrollX::GetSLegendFontSize()
  451. {
  452.     long result;
  453.     GetProperty(0x23, VT_I4, (void*)&result);
  454.     return result;
  455. }
  456.  
  457. void CScrollX::SetSLegendFontSize(long propVal)
  458. {
  459.     SetProperty(0x23, VT_I4, propVal);
  460. }
  461.  
  462. BOOL CScrollX::GetEnableInternalTimer()
  463. {
  464.     BOOL result;
  465.     GetProperty(0x24, VT_BOOL, (void*)&result);
  466.     return result;
  467. }
  468.  
  469. void CScrollX::SetEnableInternalTimer(BOOL propVal)
  470. {
  471.     SetProperty(0x24, VT_BOOL, propVal);
  472. }
  473.  
  474. double CScrollX::GetTimerFrequency()
  475. {
  476.     double result;
  477.     GetProperty(0x25, VT_R8, (void*)&result);
  478.     return result;
  479. }
  480.  
  481. void CScrollX::SetTimerFrequency(double propVal)
  482. {
  483.     SetProperty(0x25, VT_R8, propVal);
  484. }
  485.  
  486. long CScrollX::GetSLegendOrientation()
  487. {
  488.     long result;
  489.     GetProperty(0x26, VT_I4, (void*)&result);
  490.     return result;
  491. }
  492.  
  493. void CScrollX::SetSLegendOrientation(long propVal)
  494. {
  495.     SetProperty(0x26, VT_I4, propVal);
  496. }
  497.  
  498. /////////////////////////////////////////////////////////////////////////////
  499. // CScrollX operations
  500.  
  501. double CScrollX::GetAxisMin(long axis)
  502. {
  503.     double result;
  504.     static BYTE parms[] =
  505.         VTS_I4;
  506.     InvokeHelper(0x3a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  507.         axis);
  508.     return result;
  509. }
  510.  
  511. void CScrollX::SetAxisMin(long axis, double newValue)
  512. {
  513.     static BYTE parms[] =
  514.         VTS_I4 VTS_R8;
  515.     InvokeHelper(0x3a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  516.          axis, newValue);
  517. }
  518.  
  519. double CScrollX::GetAxisMax(short axis)
  520. {
  521.     double result;
  522.     static BYTE parms[] =
  523.         VTS_I2;
  524.     InvokeHelper(0x3b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  525.         axis);
  526.     return result;
  527. }
  528.  
  529. void CScrollX::SetAxisMax(short axis, double newValue)
  530. {
  531.     static BYTE parms[] =
  532.         VTS_I2 VTS_R8;
  533.     InvokeHelper(0x3b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  534.          axis, newValue);
  535. }
  536.  
  537. BOOL CScrollX::GetScaleEnable(short axis)
  538. {
  539.     BOOL result;
  540.     static BYTE parms[] =
  541.         VTS_I2;
  542.     InvokeHelper(0x3c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  543.         axis);
  544.     return result;
  545. }
  546.  
  547. void CScrollX::SetScaleEnable(short axis, BOOL bNewValue)
  548. {
  549.     static BYTE parms[] =
  550.         VTS_I2 VTS_BOOL;
  551.     InvokeHelper(0x3c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  552.          axis, bNewValue);
  553. }
  554.  
  555. BOOL CScrollX::GetAxisEnable(short axis)
  556. {
  557.     BOOL result;
  558.     static BYTE parms[] =
  559.         VTS_I2;
  560.     InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  561.         axis);
  562.     return result;
  563. }
  564.  
  565. void CScrollX::SetAxisEnable(short axis, BOOL bNewValue)
  566. {
  567.     static BYTE parms[] =
  568.         VTS_I2 VTS_BOOL;
  569.     InvokeHelper(0x3d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  570.          axis, bNewValue);
  571. }
  572.  
  573. BOOL CScrollX::GetAxisInterceptTrack(short axis)
  574. {
  575.     BOOL result;
  576.     static BYTE parms[] =
  577.         VTS_I2;
  578.     InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  579.         axis);
  580.     return result;
  581. }
  582.  
  583. void CScrollX::SetAxisInterceptTrack(short axis, BOOL bNewValue)
  584. {
  585.     static BYTE parms[] =
  586.         VTS_I2 VTS_BOOL;
  587.     InvokeHelper(0x3e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  588.          axis, bNewValue);
  589. }
  590.  
  591. BOOL CScrollX::GetAxisLabelsEnable(short axis)
  592. {
  593.     BOOL result;
  594.     static BYTE parms[] =
  595.         VTS_I2;
  596.     InvokeHelper(0x3f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  597.         axis);
  598.     return result;
  599. }
  600.  
  601. void CScrollX::SetAxisLabelsEnable(short axis, BOOL bNewValue)
  602. {
  603.     static BYTE parms[] =
  604.         VTS_I2 VTS_BOOL;
  605.     InvokeHelper(0x3f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  606.          axis, bNewValue);
  607. }
  608.  
  609. long CScrollX::GetAxisScaleMode(short axis)
  610. {
  611.     long result;
  612.     static BYTE parms[] =
  613.         VTS_I2;
  614.     InvokeHelper(0x40, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  615.         axis);
  616.     return result;
  617. }
  618.  
  619. void CScrollX::SetAxisScaleMode(short axis, long nNewValue)
  620. {
  621.     static BYTE parms[] =
  622.         VTS_I2 VTS_I4;
  623.     InvokeHelper(0x40, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  624.          axis, nNewValue);
  625. }
  626.  
  627. double CScrollX::GetAxisIntercept(short axis)
  628. {
  629.     double result;
  630.     static BYTE parms[] =
  631.         VTS_I2;
  632.     InvokeHelper(0x41, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  633.         axis);
  634.     return result;
  635. }
  636.  
  637. void CScrollX::SetAxisIntercept(short axis, double newValue)
  638. {
  639.     static BYTE parms[] =
  640.         VTS_I2 VTS_R8;
  641.     InvokeHelper(0x41, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  642.          axis, newValue);
  643. }
  644.  
  645. long CScrollX::GetAxisColor(short axis)
  646. {
  647.     long result;
  648.     static BYTE parms[] =
  649.         VTS_I2;
  650.     InvokeHelper(0x42, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  651.         axis);
  652.     return result;
  653. }
  654.  
  655. void CScrollX::SetAxisColor(short axis, long nNewValue)
  656. {
  657.     static BYTE parms[] =
  658.         VTS_I2 VTS_I4;
  659.     InvokeHelper(0x42, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  660.          axis, nNewValue);
  661. }
  662.  
  663. long CScrollX::GetAxisLineWidth(short axis)
  664. {
  665.     long result;
  666.     static BYTE parms[] =
  667.         VTS_I2;
  668.     InvokeHelper(0x43, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  669.         axis);
  670.     return result;
  671. }
  672.  
  673. void CScrollX::SetAxisLineWidth(short axis, long nNewValue)
  674. {
  675.     static BYTE parms[] =
  676.         VTS_I2 VTS_I4;
  677.     InvokeHelper(0x43, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  678.          axis, nNewValue);
  679. }
  680.  
  681. long CScrollX::GetAxisMinorTicks(short axis)
  682. {
  683.     long result;
  684.     static BYTE parms[] =
  685.         VTS_I2;
  686.     InvokeHelper(0x44, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  687.         axis);
  688.     return result;
  689. }
  690.  
  691. void CScrollX::SetAxisMinorTicks(short axis, long nNewValue)
  692. {
  693.     static BYTE parms[] =
  694.         VTS_I2 VTS_I4;
  695.     InvokeHelper(0x44, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  696.          axis, nNewValue);
  697. }
  698.  
  699. double CScrollX::GetAxisMajorTickInterval(short axis)
  700. {
  701.     double result;
  702.     static BYTE parms[] =
  703.         VTS_I2;
  704.     InvokeHelper(0x45, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  705.         axis);
  706.     return result;
  707. }
  708.  
  709. void CScrollX::SetAxisMajorTickInterval(short axis, double newValue)
  710. {
  711.     static BYTE parms[] =
  712.         VTS_I2 VTS_R8;
  713.     InvokeHelper(0x45, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  714.          axis, newValue);
  715. }
  716.  
  717. long CScrollX::GetAxisTickStyle(short axis)
  718. {
  719.     long result;
  720.     static BYTE parms[] =
  721.         VTS_I2;
  722.     InvokeHelper(0x46, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  723.         axis);
  724.     return result;
  725. }
  726.  
  727. void CScrollX::SetAxisTickStyle(short axis, long nNewValue)
  728. {
  729.     static BYTE parms[] =
  730.         VTS_I2 VTS_I4;
  731.     InvokeHelper(0x46, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  732.          axis, nNewValue);
  733. }
  734.  
  735. long CScrollX::GetAxisLabelPos(short axis)
  736. {
  737.     long result;
  738.     static BYTE parms[] =
  739.         VTS_I2;
  740.     InvokeHelper(0x47, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  741.         axis);
  742.     return result;
  743. }
  744.  
  745. void CScrollX::SetAxisLabelPos(short axis, long nNewValue)
  746. {
  747.     static BYTE parms[] =
  748.         VTS_I2 VTS_I4;
  749.     InvokeHelper(0x47, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  750.          axis, nNewValue);
  751. }
  752.  
  753. long CScrollX::GetAxisLabelDecs(short axis)
  754. {
  755.     long result;
  756.     static BYTE parms[] =
  757.         VTS_I2;
  758.     InvokeHelper(0x48, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  759.         axis);
  760.     return result;
  761. }
  762.  
  763. void CScrollX::SetAxisLabelDecs(short axis, long nNewValue)
  764. {
  765.     static BYTE parms[] =
  766.         VTS_I2 VTS_I4;
  767.     InvokeHelper(0x48, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  768.          axis, nNewValue);
  769. }
  770.  
  771. long CScrollX::GetAxisLabelColor(short axis)
  772. {
  773.     long result;
  774.     static BYTE parms[] =
  775.         VTS_I2;
  776.     InvokeHelper(0x49, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  777.         axis);
  778.     return result;
  779. }
  780.  
  781. void CScrollX::SetAxisLabelColor(short axis, long nNewValue)
  782. {
  783.     static BYTE parms[] =
  784.         VTS_I2 VTS_I4;
  785.     InvokeHelper(0x49, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  786.          axis, nNewValue);
  787. }
  788.  
  789. CString CScrollX::GetAxisLabelFont(short axis)
  790. {
  791.     CString result;
  792.     static BYTE parms[] =
  793.         VTS_I2;
  794.     InvokeHelper(0x4a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  795.         axis);
  796.     return result;
  797. }
  798.  
  799. void CScrollX::SetAxisLabelFont(short axis, LPCTSTR lpszNewValue)
  800. {
  801.     static BYTE parms[] =
  802.         VTS_I2 VTS_BSTR;
  803.     InvokeHelper(0x4a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  804.          axis, lpszNewValue);
  805. }
  806.  
  807. long CScrollX::GetAxisLabelFontStyle(short axis)
  808. {
  809.     long result;
  810.     static BYTE parms[] =
  811.         VTS_I2;
  812.     InvokeHelper(0x4b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  813.         axis);
  814.     return result;
  815. }
  816.  
  817. void CScrollX::SetAxisLabelFontStyle(short axis, long nNewValue)
  818. {
  819.     static BYTE parms[] =
  820.         VTS_I2 VTS_I4;
  821.     InvokeHelper(0x4b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  822.          axis, nNewValue);
  823. }
  824.  
  825. long CScrollX::GetAxisLabelFontSize(short axis)
  826. {
  827.     long result;
  828.     static BYTE parms[] =
  829.         VTS_I2;
  830.     InvokeHelper(0x4c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  831.         axis);
  832.     return result;
  833. }
  834.  
  835. void CScrollX::SetAxisLabelFontSize(short axis, long nNewValue)
  836. {
  837.     static BYTE parms[] =
  838.         VTS_I2 VTS_I4;
  839.     InvokeHelper(0x4c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  840.          axis, nNewValue);
  841. }
  842.  
  843. long CScrollX::GetAxisNumericStyle(short axis)
  844. {
  845.     long result;
  846.     static BYTE parms[] =
  847.         VTS_I2;
  848.     InvokeHelper(0x4d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  849.         axis);
  850.     return result;
  851. }
  852.  
  853. void CScrollX::SetAxisNumericStyle(short axis, long nNewValue)
  854. {
  855.     static BYTE parms[] =
  856.         VTS_I2 VTS_I4;
  857.     InvokeHelper(0x4d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  858.          axis, nNewValue);
  859. }
  860.  
  861. CString CScrollX::GetAxisTitleString(short axis)
  862. {
  863.     CString result;
  864.     static BYTE parms[] =
  865.         VTS_I2;
  866.     InvokeHelper(0x4e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  867.         axis);
  868.     return result;
  869. }
  870.  
  871. void CScrollX::SetAxisTitleString(short axis, LPCTSTR lpszNewValue)
  872. {
  873.     static BYTE parms[] =
  874.         VTS_I2 VTS_BSTR;
  875.     InvokeHelper(0x4e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  876.          axis, lpszNewValue);
  877. }
  878.  
  879. CString CScrollX::GetAxisTitleFont(short axis)
  880. {
  881.     CString result;
  882.     static BYTE parms[] =
  883.         VTS_I2;
  884.     InvokeHelper(0x4f, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  885.         axis);
  886.     return result;
  887. }
  888.  
  889. void CScrollX::SetAxisTitleFont(short axis, LPCTSTR lpszNewValue)
  890. {
  891.     static BYTE parms[] =
  892.         VTS_I2 VTS_BSTR;
  893.     InvokeHelper(0x4f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  894.          axis, lpszNewValue);
  895. }
  896.  
  897. CString CScrollX::GetAxisLabelStrings(short axis)
  898. {
  899.     CString result;
  900.     static BYTE parms[] =
  901.         VTS_I2;
  902.     InvokeHelper(0x50, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  903.         axis);
  904.     return result;
  905. }
  906.  
  907. void CScrollX::SetAxisLabelStrings(short axis, LPCTSTR lpszNewValue)
  908. {
  909.     static BYTE parms[] =
  910.         VTS_I2 VTS_BSTR;
  911.     InvokeHelper(0x50, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  912.          axis, lpszNewValue);
  913. }
  914.  
  915. long CScrollX::GetNumAxisLabelStrings(short axis)
  916. {
  917.     long result;
  918.     static BYTE parms[] =
  919.         VTS_I2;
  920.     InvokeHelper(0x51, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  921.         axis);
  922.     return result;
  923. }
  924.  
  925. void CScrollX::SetNumAxisLabelStrings(short axis, long nNewValue)
  926. {
  927.     static BYTE parms[] =
  928.         VTS_I2 VTS_I4;
  929.     InvokeHelper(0x51, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  930.          axis, nNewValue);
  931. }
  932.  
  933. BOOL CScrollX::GetAxisLabelStringsEnable(short axis)
  934. {
  935.     BOOL result;
  936.     static BYTE parms[] =
  937.         VTS_I2;
  938.     InvokeHelper(0x52, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  939.         axis);
  940.     return result;
  941. }
  942.  
  943. void CScrollX::SetAxisLabelStringsEnable(short axis, BOOL bNewValue)
  944. {
  945.     static BYTE parms[] =
  946.         VTS_I2 VTS_BOOL;
  947.     InvokeHelper(0x52, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  948.          axis, bNewValue);
  949. }
  950.  
  951. long CScrollX::GetAxisLabelStringsStart(short axis)
  952. {
  953.     long result;
  954.     static BYTE parms[] =
  955.         VTS_I2;
  956.     InvokeHelper(0x53, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  957.         axis);
  958.     return result;
  959. }
  960.  
  961. void CScrollX::SetAxisLabelStringsStart(short axis, long nNewValue)
  962. {
  963.     static BYTE parms[] =
  964.         VTS_I2 VTS_I4;
  965.     InvokeHelper(0x53, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  966.          axis, nNewValue);
  967. }
  968.  
  969. long CScrollX::GetAxisTitleColor(short axis)
  970. {
  971.     long result;
  972.     static BYTE parms[] =
  973.         VTS_I2;
  974.     InvokeHelper(0x54, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  975.         axis);
  976.     return result;
  977. }
  978.  
  979. void CScrollX::SetAxisTitleColor(short axis, long nNewValue)
  980. {
  981.     static BYTE parms[] =
  982.         VTS_I2 VTS_I4;
  983.     InvokeHelper(0x54, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  984.          axis, nNewValue);
  985. }
  986.  
  987. long CScrollX::GetAxisTitleFontStyle(short axis)
  988. {
  989.     long result;
  990.     static BYTE parms[] =
  991.         VTS_I2;
  992.     InvokeHelper(0x55, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  993.         axis);
  994.     return result;
  995. }
  996.  
  997. void CScrollX::SetAxisTitleFontStyle(short axis, long nNewValue)
  998. {
  999.     static BYTE parms[] =
  1000.         VTS_I2 VTS_I4;
  1001.     InvokeHelper(0x55, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1002.          axis, nNewValue);
  1003. }
  1004.  
  1005. long CScrollX::GetAxisTitleFontSize(short axis)
  1006. {
  1007.     long result;
  1008.     static BYTE parms[] =
  1009.         VTS_I2;
  1010.     InvokeHelper(0x56, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1011.         axis);
  1012.     return result;
  1013. }
  1014.  
  1015. void CScrollX::SetAxisTitleFontSize(short axis, long nNewValue)
  1016. {
  1017.     static BYTE parms[] =
  1018.         VTS_I2 VTS_I4;
  1019.     InvokeHelper(0x56, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1020.          axis, nNewValue);
  1021. }
  1022.  
  1023. long CScrollX::GetAxisTitlePos(short axis)
  1024. {
  1025.     long result;
  1026.     static BYTE parms[] =
  1027.         VTS_I2;
  1028.     InvokeHelper(0x57, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1029.         axis);
  1030.     return result;
  1031. }
  1032.  
  1033. void CScrollX::SetAxisTitlePos(short axis, long nNewValue)
  1034. {
  1035.     static BYTE parms[] =
  1036.         VTS_I2 VTS_I4;
  1037.     InvokeHelper(0x57, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1038.          axis, nNewValue);
  1039. }
  1040.  
  1041. BOOL CScrollX::GetAxisGridEnable(short axis)
  1042. {
  1043.     BOOL result;
  1044.     static BYTE parms[] =
  1045.         VTS_I2;
  1046.     InvokeHelper(0x58, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1047.         axis);
  1048.     return result;
  1049. }
  1050.  
  1051. void CScrollX::SetAxisGridEnable(short axis, BOOL bNewValue)
  1052. {
  1053.     static BYTE parms[] =
  1054.         VTS_I2 VTS_BOOL;
  1055.     InvokeHelper(0x58, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1056.          axis, bNewValue);
  1057. }
  1058.  
  1059. long CScrollX::GetAxisGridColor(short axis)
  1060. {
  1061.     long result;
  1062.     static BYTE parms[] =
  1063.         VTS_I2;
  1064.     InvokeHelper(0x59, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1065.         axis);
  1066.     return result;
  1067. }
  1068.  
  1069. void CScrollX::SetAxisGridColor(short axis, long nNewValue)
  1070. {
  1071.     static BYTE parms[] =
  1072.         VTS_I2 VTS_I4;
  1073.     InvokeHelper(0x59, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1074.          axis, nNewValue);
  1075. }
  1076.  
  1077. long CScrollX::GetAxisGridLineWidth(short axis)
  1078. {
  1079.     long result;
  1080.     static BYTE parms[] =
  1081.         VTS_I2;
  1082.     InvokeHelper(0x5a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1083.         axis);
  1084.     return result;
  1085. }
  1086.  
  1087. void CScrollX::SetAxisGridLineWidth(short axis, long nNewValue)
  1088. {
  1089.     static BYTE parms[] =
  1090.         VTS_I2 VTS_I4;
  1091.     InvokeHelper(0x5a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1092.          axis, nNewValue);
  1093. }
  1094.  
  1095. long CScrollX::GetAxisGridLineStyle(short axis)
  1096. {
  1097.     long result;
  1098.     static BYTE parms[] =
  1099.         VTS_I2;
  1100.     InvokeHelper(0x5b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1101.         axis);
  1102.     return result;
  1103. }
  1104.  
  1105. void CScrollX::SetAxisGridLineStyle(short axis, long nNewValue)
  1106. {
  1107.     static BYTE parms[] =
  1108.         VTS_I2 VTS_I4;
  1109.     InvokeHelper(0x5b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1110.          axis, nNewValue);
  1111. }
  1112.  
  1113. long CScrollX::GetAxisGridType(short axis)
  1114. {
  1115.     long result;
  1116.     static BYTE parms[] =
  1117.         VTS_I2;
  1118.     InvokeHelper(0x5c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1119.         axis);
  1120.     return result;
  1121. }
  1122.  
  1123. void CScrollX::SetAxisGridType(short axis, long nNewValue)
  1124. {
  1125.     static BYTE parms[] =
  1126.         VTS_I2 VTS_I4;
  1127.     InvokeHelper(0x5c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1128.          axis, nNewValue);
  1129. }
  1130.  
  1131. CString CScrollX::GetTitleString(short title)
  1132. {
  1133.     CString result;
  1134.     static BYTE parms[] =
  1135.         VTS_I2;
  1136.     InvokeHelper(0x5d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  1137.         title);
  1138.     return result;
  1139. }
  1140.  
  1141. void CScrollX::SetTitleString(short title, LPCTSTR lpszNewValue)
  1142. {
  1143.     static BYTE parms[] =
  1144.         VTS_I2 VTS_BSTR;
  1145.     InvokeHelper(0x5d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1146.          title, lpszNewValue);
  1147. }
  1148.  
  1149. CString CScrollX::GetTitleFont(short title)
  1150. {
  1151.     CString result;
  1152.     static BYTE parms[] =
  1153.         VTS_I2;
  1154.     InvokeHelper(0x5e, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  1155.         title);
  1156.     return result;
  1157. }
  1158.  
  1159. void CScrollX::SetTitleFont(short title, LPCTSTR lpszNewValue)
  1160. {
  1161.     static BYTE parms[] =
  1162.         VTS_I2 VTS_BSTR;
  1163.     InvokeHelper(0x5e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1164.          title, lpszNewValue);
  1165. }
  1166.  
  1167. long CScrollX::GetTitleColor(short title)
  1168. {
  1169.     long result;
  1170.     static BYTE parms[] =
  1171.         VTS_I2;
  1172.     InvokeHelper(0x5f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1173.         title);
  1174.     return result;
  1175. }
  1176.  
  1177. void CScrollX::SetTitleColor(short title, long nNewValue)
  1178. {
  1179.     static BYTE parms[] =
  1180.         VTS_I2 VTS_I4;
  1181.     InvokeHelper(0x5f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1182.          title, nNewValue);
  1183. }
  1184.  
  1185. long CScrollX::GetTitleFontStyle(short axis)
  1186. {
  1187.     long result;
  1188.     static BYTE parms[] =
  1189.         VTS_I2;
  1190.     InvokeHelper(0x60, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1191.         axis);
  1192.     return result;
  1193. }
  1194.  
  1195. void CScrollX::SetTitleFontStyle(short axis, long nNewValue)
  1196. {
  1197.     static BYTE parms[] =
  1198.         VTS_I2 VTS_I4;
  1199.     InvokeHelper(0x60, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1200.          axis, nNewValue);
  1201. }
  1202.  
  1203. long CScrollX::GetTitleFontSize(short title)
  1204. {
  1205.     long result;
  1206.     static BYTE parms[] =
  1207.         VTS_I2;
  1208.     InvokeHelper(0x61, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1209.         title);
  1210.     return result;
  1211. }
  1212.  
  1213. void CScrollX::SetTitleFontSize(short title, long nNewValue)
  1214. {
  1215.     static BYTE parms[] =
  1216.         VTS_I2 VTS_I4;
  1217.     InvokeHelper(0x61, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1218.          title, nNewValue);
  1219. }
  1220.  
  1221. long CScrollX::GetTitlePos(short title)
  1222. {
  1223.     long result;
  1224.     static BYTE parms[] =
  1225.         VTS_I2;
  1226.     InvokeHelper(0x62, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1227.         title);
  1228.     return result;
  1229. }
  1230.  
  1231. void CScrollX::SetTitlePos(short title, long nNewValue)
  1232. {
  1233.     static BYTE parms[] =
  1234.         VTS_I2 VTS_I4;
  1235.     InvokeHelper(0x62, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1236.          title, nNewValue);
  1237. }
  1238.  
  1239. long CScrollX::GetSPlotType(short dataset)
  1240. {
  1241.     long result;
  1242.     static BYTE parms[] =
  1243.         VTS_I2;
  1244.     InvokeHelper(0x63, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1245.         dataset);
  1246.     return result;
  1247. }
  1248.  
  1249. void CScrollX::SetSPlotType(short dataset, long nNewValue)
  1250. {
  1251.     static BYTE parms[] =
  1252.         VTS_I2 VTS_I4;
  1253.     InvokeHelper(0x63, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1254.          dataset, nNewValue);
  1255. }
  1256.  
  1257. long CScrollX::GetSPlotRefAxes(short dataset)
  1258. {
  1259.     long result;
  1260.     static BYTE parms[] =
  1261.         VTS_I2;
  1262.     InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1263.         dataset);
  1264.     return result;
  1265. }
  1266.  
  1267. void CScrollX::SetSPlotRefAxes(short dataset, long nNewValue)
  1268. {
  1269.     static BYTE parms[] =
  1270.         VTS_I2 VTS_I4;
  1271.     InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1272.          dataset, nNewValue);
  1273. }
  1274.  
  1275. long CScrollX::GetSDataNumPlotPoints(short dataset)
  1276. {
  1277.     long result;
  1278.     static BYTE parms[] =
  1279.         VTS_I2;
  1280.     InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1281.         dataset);
  1282.     return result;
  1283. }
  1284.  
  1285. void CScrollX::SetSDataNumPlotPoints(short dataset, long nNewValue)
  1286. {
  1287.     static BYTE parms[] =
  1288.         VTS_I2 VTS_I4;
  1289.     InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1290.          dataset, nNewValue);
  1291. }
  1292.  
  1293. CString CScrollX::GetSDataName(short dataset)
  1294. {
  1295.     CString result;
  1296.     static BYTE parms[] =
  1297.         VTS_I2;
  1298.     InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  1299.         dataset);
  1300.     return result;
  1301. }
  1302.  
  1303. void CScrollX::SetSDataName(short dataset, LPCTSTR lpszNewValue)
  1304. {
  1305.     static BYTE parms[] =
  1306.         VTS_I2 VTS_BSTR;
  1307.     InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1308.          dataset, lpszNewValue);
  1309. }
  1310.  
  1311. BOOL CScrollX::GetSDataEnable(short dataset)
  1312. {
  1313.     BOOL result;
  1314.     static BYTE parms[] =
  1315.         VTS_I2;
  1316.     InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1317.         dataset);
  1318.     return result;
  1319. }
  1320.  
  1321. void CScrollX::SetSDataEnable(short dataset, BOOL bNewValue)
  1322. {
  1323.     static BYTE parms[] =
  1324.         VTS_I2 VTS_BOOL;
  1325.     InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1326.          dataset, bNewValue);
  1327. }
  1328.  
  1329. long CScrollX::GetSDataType(short dataset)
  1330. {
  1331.     long result;
  1332.     static BYTE parms[] =
  1333.         VTS_I2;
  1334.     InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1335.         dataset);
  1336.     return result;
  1337. }
  1338.  
  1339. void CScrollX::SetSDataType(short dataset, long nNewValue)
  1340. {
  1341.     static BYTE parms[] =
  1342.         VTS_I2 VTS_I4;
  1343.     InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1344.          dataset, nNewValue);
  1345. }
  1346.  
  1347. long CScrollX::GetSDataNumGroups(short dataset)
  1348. {
  1349.     long result;
  1350.     static BYTE parms[] =
  1351.         VTS_I2;
  1352.     InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1353.         dataset);
  1354.     return result;
  1355. }
  1356.  
  1357. void CScrollX::SetSDataNumGroups(short dataset, long nNewValue)
  1358. {
  1359.     static BYTE parms[] =
  1360.         VTS_I2 VTS_I4;
  1361.     InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1362.          dataset, nNewValue);
  1363. }
  1364.  
  1365. BOOL CScrollX::GetAxisAutoAxis(short axis)
  1366. {
  1367.     BOOL result;
  1368.     static BYTE parms[] =
  1369.         VTS_I2;
  1370.     InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1371.         axis);
  1372.     return result;
  1373. }
  1374.  
  1375. void CScrollX::SetAxisAutoAxis(short axis, BOOL bNewValue)
  1376. {
  1377.     static BYTE parms[] =
  1378.         VTS_I2 VTS_BOOL;
  1379.     InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1380.          axis, bNewValue);
  1381. }
  1382.  
  1383. void CScrollX::UpdateGraph()
  1384. {
  1385.     InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1386. }
  1387.  
  1388. double CScrollX::GetXDataValues(short dataset, long nIndex)
  1389. {
  1390.     double result;
  1391.     static BYTE parms[] =
  1392.         VTS_I2 VTS_I4;
  1393.     InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1394.         dataset, nIndex);
  1395.     return result;
  1396. }
  1397.  
  1398. void CScrollX::SetXDataValues(short dataset, long nIndex, double newValue)
  1399. {
  1400.     static BYTE parms[] =
  1401.         VTS_I2 VTS_I4 VTS_R8;
  1402.     InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1403.          dataset, nIndex, newValue);
  1404. }
  1405.  
  1406. double CScrollX::GetYDataValues(short dataset, long nIndex, long nGroup)
  1407. {
  1408.     double result;
  1409.     static BYTE parms[] =
  1410.         VTS_I2 VTS_I4 VTS_I4;
  1411.     InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1412.         dataset, nIndex, nGroup);
  1413.     return result;
  1414. }
  1415.  
  1416. void CScrollX::SetYDataValues(short dataset, long nIndex, long nGroup, double newValue)
  1417. {
  1418.     static BYTE parms[] =
  1419.         VTS_I2 VTS_I4 VTS_I4 VTS_R8;
  1420.     InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1421.          dataset, nIndex, nGroup, newValue);
  1422. }
  1423.  
  1424. BOOL CScrollX::SavePageMeta(long mftype, LPCTSTR filename)
  1425. {
  1426.     BOOL result;
  1427.     static BYTE parms[] =
  1428.         VTS_I4 VTS_BSTR;
  1429.     InvokeHelper(0x2a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1430.         mftype, filename);
  1431.     return result;
  1432. }
  1433.  
  1434. long CScrollX::GetSDataXData(long index)
  1435. {
  1436.     long result;
  1437.     static BYTE parms[] =
  1438.         VTS_I4;
  1439.     InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1440.         index);
  1441.     return result;
  1442. }
  1443.  
  1444. void CScrollX::SetSDataXData(long index, long nNewValue)
  1445. {
  1446.     static BYTE parms[] =
  1447.         VTS_I4 VTS_I4;
  1448.     InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1449.          index, nNewValue);
  1450. }
  1451.  
  1452. long CScrollX::GetGetSDataYData(long index)
  1453. {
  1454.     long result;
  1455.     static BYTE parms[] =
  1456.         VTS_I4;
  1457.     InvokeHelper(0x6e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1458.         index);
  1459.     return result;
  1460. }
  1461.  
  1462. void CScrollX::SetGetSDataYData(long index, long nNewValue)
  1463. {
  1464.     static BYTE parms[] =
  1465.         VTS_I4 VTS_I4;
  1466.     InvokeHelper(0x6e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1467.          index, nNewValue);
  1468. }
  1469.  
  1470. void CScrollX::FFTDSPWindow(double* pRealData, double* pImData, long nNumDataPoints, long nWindowType)
  1471. {
  1472.     static BYTE parms[] =
  1473.         VTS_PR8 VTS_PR8 VTS_I4 VTS_I4;
  1474.     InvokeHelper(0x2b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1475.          pRealData, pImData, nNumDataPoints, nWindowType);
  1476. }
  1477.  
  1478. void CScrollX::FFTComplexFFT(double* pRealData, double* pImData, long nNumDataPoints, BOOL bInverse)
  1479. {
  1480.     static BYTE parms[] =
  1481.         VTS_PR8 VTS_PR8 VTS_I4 VTS_BOOL;
  1482.     InvokeHelper(0x2c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1483.          pRealData, pImData, nNumDataPoints, bInverse);
  1484. }
  1485.  
  1486. void CScrollX::FFTRealFFT(double* pRealData, double* pImData, long nNumDataPoints, BOOL bInverse)
  1487. {
  1488.     static BYTE parms[] =
  1489.         VTS_PR8 VTS_PR8 VTS_I4 VTS_BOOL;
  1490.     InvokeHelper(0x2d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1491.          pRealData, pImData, nNumDataPoints, bInverse);
  1492. }
  1493.  
  1494. void CScrollX::FFTPowerSpectrum(double* pRealData, double* pImData, long nNumDataPoints, double rInterval)
  1495. {
  1496.     static BYTE parms[] =
  1497.         VTS_PR8 VTS_PR8 VTS_I4 VTS_R8;
  1498.     InvokeHelper(0x2e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1499.          pRealData, pImData, nNumDataPoints, rInterval);
  1500. }
  1501.  
  1502. double CScrollX::FFTMagnitude(double* pRealData, double* pImData, long nNumDataPoints, long index)
  1503. {
  1504.     double result;
  1505.     static BYTE parms[] =
  1506.         VTS_PR8 VTS_PR8 VTS_I4 VTS_I4;
  1507.     InvokeHelper(0x2f, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
  1508.         pRealData, pImData, nNumDataPoints, index);
  1509.     return result;
  1510. }
  1511.  
  1512. double CScrollX::FFTPhase(double* pRealData, double* pImData, long nNumDataPoints, long index)
  1513. {
  1514.     double result;
  1515.     static BYTE parms[] =
  1516.         VTS_PR8 VTS_PR8 VTS_I4 VTS_I4;
  1517.     InvokeHelper(0x30, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
  1518.         pRealData, pImData, nNumDataPoints, index);
  1519.     return result;
  1520. }
  1521.  
  1522. double CScrollX::FFTFrequency(long nNumDataPoints, double rSampleFreq, long index)
  1523. {
  1524.     double result;
  1525.     static BYTE parms[] =
  1526.         VTS_I4 VTS_R8 VTS_I4;
  1527.     InvokeHelper(0x31, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
  1528.         nNumDataPoints, rSampleFreq, index);
  1529.     return result;
  1530. }
  1531.  
  1532. long CScrollX::GetScrollStepMode(long dataset)
  1533. {
  1534.     long result;
  1535.     static BYTE parms[] =
  1536.         VTS_I4;
  1537.     InvokeHelper(0x6f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1538.         dataset);
  1539.     return result;
  1540. }
  1541.  
  1542. void CScrollX::SetScrollStepMode(long dataset, long nNewValue)
  1543. {
  1544.     static BYTE parms[] =
  1545.         VTS_I4 VTS_I4;
  1546.     InvokeHelper(0x6f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1547.          dataset, nNewValue);
  1548. }
  1549.  
  1550. long CScrollX::GetScrollSweepLineColor(long dataset)
  1551. {
  1552.     long result;
  1553.     static BYTE parms[] =
  1554.         VTS_I4;
  1555.     InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1556.         dataset);
  1557.     return result;
  1558. }
  1559.  
  1560. void CScrollX::SetScrollSweepLineColor(long dataset, long nNewValue)
  1561. {
  1562.     static BYTE parms[] =
  1563.         VTS_I4 VTS_I4;
  1564.     InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1565.          dataset, nNewValue);
  1566. }
  1567.  
  1568. double CScrollX::GetScrollRelReset(long dataset)
  1569. {
  1570.     double result;
  1571.     static BYTE parms[] =
  1572.         VTS_I4;
  1573.     InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1574.         dataset);
  1575.     return result;
  1576. }
  1577.  
  1578. void CScrollX::SetScrollRelReset(long dataset, double newValue)
  1579. {
  1580.     static BYTE parms[] =
  1581.         VTS_I4 VTS_R8;
  1582.     InvokeHelper(0x71, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1583.          dataset, newValue);
  1584. }
  1585.  
  1586. double CScrollX::GetScrollRelSize(long dataset)
  1587. {
  1588.     double result;
  1589.     static BYTE parms[] =
  1590.         VTS_I4;
  1591.     InvokeHelper(0x72, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1592.         dataset);
  1593.     return result;
  1594. }
  1595.  
  1596. void CScrollX::SetScrollRelSize(long dataset, double newValue)
  1597. {
  1598.     static BYTE parms[] =
  1599.         VTS_I4 VTS_R8;
  1600.     InvokeHelper(0x72, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1601.          dataset, newValue);
  1602. }
  1603.  
  1604. double CScrollX::GetScrollSampleInterval(long dataset)
  1605. {
  1606.     double result;
  1607.     static BYTE parms[] =
  1608.         VTS_I4;
  1609.     InvokeHelper(0x73, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1610.         dataset);
  1611.     return result;
  1612. }
  1613.  
  1614. void CScrollX::SetScrollSampleInterval(long dataset, double newValue)
  1615. {
  1616.     static BYTE parms[] =
  1617.         VTS_I4 VTS_R8;
  1618.     InvokeHelper(0x73, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1619.          dataset, newValue);
  1620. }
  1621.  
  1622. long CScrollX::GetScrollXYNumPoints(long dataset)
  1623. {
  1624.     long result;
  1625.     static BYTE parms[] =
  1626.         VTS_I4;
  1627.     InvokeHelper(0x74, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1628.         dataset);
  1629.     return result;
  1630. }
  1631.  
  1632. void CScrollX::SetScrollXYNumPoints(long dataset, long nNewValue)
  1633. {
  1634.     static BYTE parms[] =
  1635.         VTS_I4 VTS_I4;
  1636.     InvokeHelper(0x74, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1637.          dataset, nNewValue);
  1638. }
  1639.  
  1640. BOOL CScrollX::GetScrollDirection(long dataset)
  1641. {
  1642.     BOOL result;
  1643.     static BYTE parms[] =
  1644.         VTS_I4;
  1645.     InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1646.         dataset);
  1647.     return result;
  1648. }
  1649.  
  1650. void CScrollX::SetScrollDirection(long dataset, BOOL bNewValue)
  1651. {
  1652.     static BYTE parms[] =
  1653.         VTS_I4 VTS_BOOL;
  1654.     InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1655.          dataset, bNewValue);
  1656. }
  1657.  
  1658. double CScrollX::GetScrollBarWidth(long dataset)
  1659. {
  1660.     double result;
  1661.     static BYTE parms[] =
  1662.         VTS_I4;
  1663.     InvokeHelper(0x76, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1664.         dataset);
  1665.     return result;
  1666. }
  1667.  
  1668. void CScrollX::SetScrollBarWidth(long dataset, double newValue)
  1669. {
  1670.     static BYTE parms[] =
  1671.         VTS_I4 VTS_R8;
  1672.     InvokeHelper(0x76, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1673.          dataset, newValue);
  1674. }
  1675.  
  1676. long CScrollX::GetScrollLineColor(long dataset, long channel)
  1677. {
  1678.     long result;
  1679.     static BYTE parms[] =
  1680.         VTS_I4 VTS_I4;
  1681.     InvokeHelper(0x77, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1682.         dataset, channel);
  1683.     return result;
  1684. }
  1685.  
  1686. void CScrollX::SetScrollLineColor(long dataset, long channel, long nNewValue)
  1687. {
  1688.     static BYTE parms[] =
  1689.         VTS_I4 VTS_I4 VTS_I4;
  1690.     InvokeHelper(0x77, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1691.          dataset, channel, nNewValue);
  1692. }
  1693.  
  1694. long CScrollX::GetScrollLineStyle(long dataset, long channel)
  1695. {
  1696.     long result;
  1697.     static BYTE parms[] =
  1698.         VTS_I4 VTS_I4;
  1699.     InvokeHelper(0x78, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1700.         dataset, channel);
  1701.     return result;
  1702. }
  1703.  
  1704. void CScrollX::SetScrollLineStyle(long dataset, long channel, long nNewValue)
  1705. {
  1706.     static BYTE parms[] =
  1707.         VTS_I4 VTS_I4 VTS_I4;
  1708.     InvokeHelper(0x78, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1709.          dataset, channel, nNewValue);
  1710. }
  1711.  
  1712. long CScrollX::GetScrollLineThickness(long dataset, long channel)
  1713. {
  1714.     long result;
  1715.     static BYTE parms[] =
  1716.         VTS_I4 VTS_I4;
  1717.     InvokeHelper(0x79, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1718.         dataset, channel);
  1719.     return result;
  1720. }
  1721.  
  1722. void CScrollX::SetScrollLineThickness(long dataset, long channel, long nNewValue)
  1723. {
  1724.     static BYTE parms[] =
  1725.         VTS_I4 VTS_I4 VTS_I4;
  1726.     InvokeHelper(0x79, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1727.          dataset, channel, nNewValue);
  1728. }
  1729.  
  1730. CString CScrollX::GetScrollTagName(long dataset, long channel)
  1731. {
  1732.     CString result;
  1733.     static BYTE parms[] =
  1734.         VTS_I4 VTS_I4;
  1735.     InvokeHelper(0x7a, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
  1736.         dataset, channel);
  1737.     return result;
  1738. }
  1739.  
  1740. void CScrollX::SetScrollTagName(long dataset, long channel, LPCTSTR lpszNewValue)
  1741. {
  1742.     static BYTE parms[] =
  1743.         VTS_I4 VTS_I4 VTS_BSTR;
  1744.     InvokeHelper(0x7a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1745.          dataset, channel, lpszNewValue);
  1746. }
  1747.  
  1748. long CScrollX::GetScrollNormalAlarmColor(long dataset)
  1749. {
  1750.     long result;
  1751.     static BYTE parms[] =
  1752.         VTS_I4;
  1753.     InvokeHelper(0x7b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1754.         dataset);
  1755.     return result;
  1756. }
  1757.  
  1758. void CScrollX::SetScrollNormalAlarmColor(long dataset, long nNewValue)
  1759. {
  1760.     static BYTE parms[] =
  1761.         VTS_I4 VTS_I4;
  1762.     InvokeHelper(0x7b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1763.          dataset, nNewValue);
  1764. }
  1765.  
  1766. long CScrollX::GetScrollLowAlarmColor(long dataset)
  1767. {
  1768.     long result;
  1769.     static BYTE parms[] =
  1770.         VTS_I4;
  1771.     InvokeHelper(0x7c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1772.         dataset);
  1773.     return result;
  1774. }
  1775.  
  1776. void CScrollX::SetScrollLowAlarmColor(long dataset, long nNewValue)
  1777. {
  1778.     static BYTE parms[] =
  1779.         VTS_I4 VTS_I4;
  1780.     InvokeHelper(0x7c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1781.          dataset, nNewValue);
  1782. }
  1783.  
  1784. long CScrollX::GetScrollHighAlarmColor(long dataset)
  1785. {
  1786.     long result;
  1787.     static BYTE parms[] =
  1788.         VTS_I4;
  1789.     InvokeHelper(0x7d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1790.         dataset);
  1791.     return result;
  1792. }
  1793.  
  1794. void CScrollX::SetScrollHighAlarmColor(long dataset, long nNewValue)
  1795. {
  1796.     static BYTE parms[] =
  1797.         VTS_I4 VTS_I4;
  1798.     InvokeHelper(0x7d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1799.          dataset, nNewValue);
  1800. }
  1801.  
  1802. long CScrollX::GetScrollLowLowAlarmColor(long dataset)
  1803. {
  1804.     long result;
  1805.     static BYTE parms[] =
  1806.         VTS_I4;
  1807.     InvokeHelper(0x7e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1808.         dataset);
  1809.     return result;
  1810. }
  1811.  
  1812. void CScrollX::SetScrollLowLowAlarmColor(long dataset, long nNewValue)
  1813. {
  1814.     static BYTE parms[] =
  1815.         VTS_I4 VTS_I4;
  1816.     InvokeHelper(0x7e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1817.          dataset, nNewValue);
  1818. }
  1819.  
  1820. long CScrollX::GetScrollHighHighAlarmColor(long dataset)
  1821. {
  1822.     long result;
  1823.     static BYTE parms[] =
  1824.         VTS_I4;
  1825.     InvokeHelper(0x7f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  1826.         dataset);
  1827.     return result;
  1828. }
  1829.  
  1830. void CScrollX::SetScrollHighHighAlarmColor(long dataset, long nNewValue)
  1831. {
  1832.     static BYTE parms[] =
  1833.         VTS_I4 VTS_I4;
  1834.     InvokeHelper(0x7f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1835.          dataset, nNewValue);
  1836. }
  1837.  
  1838. BOOL CScrollX::GetScrollHighHighAlarmEnable(long dataset)
  1839. {
  1840.     BOOL result;
  1841.     static BYTE parms[] =
  1842.         VTS_I4;
  1843.     InvokeHelper(0x80, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1844.         dataset);
  1845.     return result;
  1846. }
  1847.  
  1848. void CScrollX::SetScrollHighHighAlarmEnable(long dataset, BOOL bNewValue)
  1849. {
  1850.     static BYTE parms[] =
  1851.         VTS_I4 VTS_BOOL;
  1852.     InvokeHelper(0x80, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1853.          dataset, bNewValue);
  1854. }
  1855.  
  1856. BOOL CScrollX::GetScrollHighAlarmEnable(long dataset)
  1857. {
  1858.     BOOL result;
  1859.     static BYTE parms[] =
  1860.         VTS_I4;
  1861.     InvokeHelper(0x81, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1862.         dataset);
  1863.     return result;
  1864. }
  1865.  
  1866. void CScrollX::SetScrollHighAlarmEnable(long dataset, BOOL bNewValue)
  1867. {
  1868.     static BYTE parms[] =
  1869.         VTS_I4 VTS_BOOL;
  1870.     InvokeHelper(0x81, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1871.          dataset, bNewValue);
  1872. }
  1873.  
  1874. BOOL CScrollX::GetScrollLowAlarmEnable(long dataset)
  1875. {
  1876.     BOOL result;
  1877.     static BYTE parms[] =
  1878.         VTS_I4;
  1879.     InvokeHelper(0x82, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1880.         dataset);
  1881.     return result;
  1882. }
  1883.  
  1884. void CScrollX::SetScrollLowAlarmEnable(long dataset, BOOL bNewValue)
  1885. {
  1886.     static BYTE parms[] =
  1887.         VTS_I4 VTS_BOOL;
  1888.     InvokeHelper(0x82, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1889.          dataset, bNewValue);
  1890. }
  1891.  
  1892. BOOL CScrollX::GetScrollLowLowAlarmEnable(long dataset)
  1893. {
  1894.     BOOL result;
  1895.     static BYTE parms[] =
  1896.         VTS_I4;
  1897.     InvokeHelper(0x83, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1898.         dataset);
  1899.     return result;
  1900. }
  1901.  
  1902. void CScrollX::SetScrollLowLowAlarmEnable(long dataset, BOOL bNewValue)
  1903. {
  1904.     static BYTE parms[] =
  1905.         VTS_I4 VTS_BOOL;
  1906.     InvokeHelper(0x83, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1907.          dataset, bNewValue);
  1908. }
  1909.  
  1910. BOOL CScrollX::GetScrollAlarmMarksEnable(long dataset)
  1911. {
  1912.     BOOL result;
  1913.     static BYTE parms[] =
  1914.         VTS_I4;
  1915.     InvokeHelper(0x84, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1916.         dataset);
  1917.     return result;
  1918. }
  1919.  
  1920. void CScrollX::SetScrollAlarmMarksEnable(long dataset, BOOL bNewValue)
  1921. {
  1922.     static BYTE parms[] =
  1923.         VTS_I4 VTS_BOOL;
  1924.     InvokeHelper(0x84, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1925.          dataset, bNewValue);
  1926. }
  1927.  
  1928. BOOL CScrollX::GetScrollSetpointEnable(long dataset)
  1929. {
  1930.     BOOL result;
  1931.     static BYTE parms[] =
  1932.         VTS_I4;
  1933.     InvokeHelper(0x85, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  1934.         dataset);
  1935.     return result;
  1936. }
  1937.  
  1938. void CScrollX::SetScrollSetpointEnable(long dataset, BOOL bNewValue)
  1939. {
  1940.     static BYTE parms[] =
  1941.         VTS_I4 VTS_BOOL;
  1942.     InvokeHelper(0x85, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1943.          dataset, bNewValue);
  1944. }
  1945.  
  1946. double CScrollX::GetScrollHighHighAlarmValue(long dataset)
  1947. {
  1948.     double result;
  1949.     static BYTE parms[] =
  1950.         VTS_I4;
  1951.     InvokeHelper(0x86, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1952.         dataset);
  1953.     return result;
  1954. }
  1955.  
  1956. void CScrollX::SetScrollHighHighAlarmValue(long dataset, double newValue)
  1957. {
  1958.     static BYTE parms[] =
  1959.         VTS_I4 VTS_R8;
  1960.     InvokeHelper(0x86, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1961.          dataset, newValue);
  1962. }
  1963.  
  1964. double CScrollX::GetScrollHighAlarmValue(long dataset)
  1965. {
  1966.     double result;
  1967.     static BYTE parms[] =
  1968.         VTS_I4;
  1969.     InvokeHelper(0x87, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1970.         dataset);
  1971.     return result;
  1972. }
  1973.  
  1974. void CScrollX::SetScrollHighAlarmValue(long dataset, double newValue)
  1975. {
  1976.     static BYTE parms[] =
  1977.         VTS_I4 VTS_R8;
  1978.     InvokeHelper(0x87, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1979.          dataset, newValue);
  1980. }
  1981.  
  1982. double CScrollX::GetScrollLowLowAlarmValue(long dataset)
  1983. {
  1984.     double result;
  1985.     static BYTE parms[] =
  1986.         VTS_I4;
  1987.     InvokeHelper(0x88, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  1988.         dataset);
  1989.     return result;
  1990. }
  1991.  
  1992. void CScrollX::SetScrollLowLowAlarmValue(long dataset, double newValue)
  1993. {
  1994.     static BYTE parms[] =
  1995.         VTS_I4 VTS_R8;
  1996.     InvokeHelper(0x88, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  1997.          dataset, newValue);
  1998. }
  1999.  
  2000. double CScrollX::GetScrollLowAlarmValue(short dataset)
  2001. {
  2002.     double result;
  2003.     static BYTE parms[] =
  2004.         VTS_I2;
  2005.     InvokeHelper(0x89, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  2006.         dataset);
  2007.     return result;
  2008. }
  2009.  
  2010. void CScrollX::SetScrollLowAlarmValue(short dataset, double newValue)
  2011. {
  2012.     static BYTE parms[] =
  2013.         VTS_I2 VTS_R8;
  2014.     InvokeHelper(0x89, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2015.          dataset, newValue);
  2016. }
  2017.  
  2018. double CScrollX::GetScrollSetpointValue(long dataset)
  2019. {
  2020.     double result;
  2021.     static BYTE parms[] =
  2022.         VTS_I4;
  2023.     InvokeHelper(0x8a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  2024.         dataset);
  2025.     return result;
  2026. }
  2027.  
  2028. void CScrollX::SetScrollSetpointValue(long dataset, double newValue)
  2029. {
  2030.     static BYTE parms[] =
  2031.         VTS_I4 VTS_R8;
  2032.     InvokeHelper(0x8a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2033.          dataset, newValue);
  2034. }
  2035.  
  2036. long CScrollX::GetAxisLabelTimeBase(long nAxis)
  2037. {
  2038.     long result;
  2039.     static BYTE parms[] =
  2040.         VTS_I4;
  2041.     InvokeHelper(0x8b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  2042.         nAxis);
  2043.     return result;
  2044. }
  2045.  
  2046. void CScrollX::SetAxisLabelTimeBase(long nAxis, long nNewValue)
  2047. {
  2048.     static BYTE parms[] =
  2049.         VTS_I4 VTS_I4;
  2050.     InvokeHelper(0x8b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2051.          nAxis, nNewValue);
  2052. }
  2053.  
  2054. BOOL CScrollX::GetAxisLabelAutoUpdate(long nAxis)
  2055. {
  2056.     BOOL result;
  2057.     static BYTE parms[] =
  2058.         VTS_I4;
  2059.     InvokeHelper(0x8c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  2060.         nAxis);
  2061.     return result;
  2062. }
  2063.  
  2064. void CScrollX::SetAxisLabelAutoUpdate(long nAxis, BOOL bNewValue)
  2065. {
  2066.     static BYTE parms[] =
  2067.         VTS_I4 VTS_BOOL;
  2068.     InvokeHelper(0x8c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2069.          nAxis, bNewValue);
  2070. }
  2071.  
  2072. long CScrollX::GetAxisLabelStartHour(long nAxis)
  2073. {
  2074.     long result;
  2075.     static BYTE parms[] =
  2076.         VTS_I4;
  2077.     InvokeHelper(0x8d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  2078.         nAxis);
  2079.     return result;
  2080. }
  2081.  
  2082. void CScrollX::SetAxisLabelStartHour(long nAxis, long nNewValue)
  2083. {
  2084.     static BYTE parms[] =
  2085.         VTS_I4 VTS_I4;
  2086.     InvokeHelper(0x8d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2087.          nAxis, nNewValue);
  2088. }
  2089.  
  2090. long CScrollX::GetAxisLabelStartMin(long nAxis)
  2091. {
  2092.     long result;
  2093.     static BYTE parms[] =
  2094.         VTS_I4;
  2095.     InvokeHelper(0x8e, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  2096.         nAxis);
  2097.     return result;
  2098. }
  2099.  
  2100. void CScrollX::SetAxisLabelStartMin(long nAxis, long nNewValue)
  2101. {
  2102.     static BYTE parms[] =
  2103.         VTS_I4 VTS_I4;
  2104.     InvokeHelper(0x8e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2105.          nAxis, nNewValue);
  2106. }
  2107.  
  2108. long CScrollX::GetAxisLabelStartSec(long nAxis)
  2109. {
  2110.     long result;
  2111.     static BYTE parms[] =
  2112.         VTS_I4;
  2113.     InvokeHelper(0x8f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  2114.         nAxis);
  2115.     return result;
  2116. }
  2117.  
  2118. void CScrollX::SetAxisLabelStartSec(long nAxis, long nNewValue)
  2119. {
  2120.     static BYTE parms[] =
  2121.         VTS_I4 VTS_I4;
  2122.     InvokeHelper(0x8f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2123.          nAxis, nNewValue);
  2124. }
  2125.  
  2126. BOOL CScrollX::SerializeLoadFile(LPCTSTR filename)
  2127. {
  2128.     BOOL result;
  2129.     static BYTE parms[] =
  2130.         VTS_BSTR;
  2131.     InvokeHelper(0x32, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  2132.         filename);
  2133.     return result;
  2134. }
  2135.  
  2136. BOOL CScrollX::SerializeSaveFile(LPCTSTR filename)
  2137. {
  2138.     BOOL result;
  2139.     static BYTE parms[] =
  2140.         VTS_BSTR;
  2141.     InvokeHelper(0x33, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  2142.         filename);
  2143.     return result;
  2144. }
  2145.  
  2146. long CScrollX::GetScrollAlarmUpdateMode(long dataset)
  2147. {
  2148.     long result;
  2149.     static BYTE parms[] =
  2150.         VTS_I4;
  2151.     InvokeHelper(0x90, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  2152.         dataset);
  2153.     return result;
  2154. }
  2155.  
  2156. void CScrollX::SetScrollAlarmUpdateMode(long dataset, long nNewValue)
  2157. {
  2158.     static BYTE parms[] =
  2159.         VTS_I4 VTS_I4;
  2160.     InvokeHelper(0x90, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2161.          dataset, nNewValue);
  2162. }
  2163.  
  2164. double CScrollX::GetScrollAlarmUpdatePeriod(long dataset)
  2165. {
  2166.     double result;
  2167.     static BYTE parms[] =
  2168.         VTS_I4;
  2169.     InvokeHelper(0x91, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  2170.         dataset);
  2171.     return result;
  2172. }
  2173.  
  2174. void CScrollX::SetScrollAlarmUpdatePeriod(long dataset, double newValue)
  2175. {
  2176.     static BYTE parms[] =
  2177.         VTS_I4 VTS_R8;
  2178.     InvokeHelper(0x91, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2179.          dataset, newValue);
  2180. }
  2181.  
  2182. BOOL CScrollX::GetScrollAlarmHorizontal(long dataset)
  2183. {
  2184.     BOOL result;
  2185.     static BYTE parms[] =
  2186.         VTS_I4;
  2187.     InvokeHelper(0x92, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  2188.         dataset);
  2189.     return result;
  2190. }
  2191.  
  2192. void CScrollX::SetScrollAlarmHorizontal(long dataset, BOOL bNewValue)
  2193. {
  2194.     static BYTE parms[] =
  2195.         VTS_I4 VTS_BOOL;
  2196.     InvokeHelper(0x92, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2197.          dataset, bNewValue);
  2198. }
  2199.  
  2200. double CScrollX::GetAxisGridUpdatePeriod(long nAxis)
  2201. {
  2202.     double result;
  2203.     static BYTE parms[] =
  2204.         VTS_I4;
  2205.     InvokeHelper(0x93, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, parms,
  2206.         nAxis);
  2207.     return result;
  2208. }
  2209.  
  2210. void CScrollX::SetAxisGridUpdatePeriod(long nAxis, double newValue)
  2211. {
  2212.     static BYTE parms[] =
  2213.         VTS_I4 VTS_R8;
  2214.     InvokeHelper(0x93, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2215.          nAxis, newValue);
  2216. }
  2217.  
  2218. long CScrollX::GetAxisGridUpdateMode(long nAxis)
  2219. {
  2220.     long result;
  2221.     static BYTE parms[] =
  2222.         VTS_I4;
  2223.     InvokeHelper(0x94, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  2224.         nAxis);
  2225.     return result;
  2226. }
  2227.  
  2228. void CScrollX::SetAxisGridUpdateMode(long nAxis, long nNewValue)
  2229. {
  2230.     static BYTE parms[] =
  2231.         VTS_I4 VTS_I4;
  2232.     InvokeHelper(0x94, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2233.          nAxis, nNewValue);
  2234. }
  2235.  
  2236. long CScrollX::GetScrollHistoryBufferSize(long nDataset)
  2237. {
  2238.     long result;
  2239.     static BYTE parms[] =
  2240.         VTS_I4;
  2241.     InvokeHelper(0x95, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  2242.         nDataset);
  2243.     return result;
  2244. }
  2245.  
  2246. void CScrollX::SetScrollHistoryBufferSize(long nDataset, long nNewValue)
  2247. {
  2248.     static BYTE parms[] =
  2249.         VTS_I4 VTS_I4;
  2250.     InvokeHelper(0x95, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2251.          nDataset, nNewValue);
  2252. }
  2253.  
  2254. void CScrollX::UpdateDynData(long nDataset, double* rNewValues)
  2255. {
  2256.     static BYTE parms[] =
  2257.         VTS_I4 VTS_PR8;
  2258.     InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2259.          nDataset, rNewValues);
  2260. }
  2261.  
  2262. void CScrollX::DefineDynDataset(long nDataset, LPCTSTR sName, long nNumTraces, long nHistBufferSize)
  2263. {
  2264.     static BYTE parms[] =
  2265.         VTS_I4 VTS_BSTR VTS_I4 VTS_I4;
  2266.     InvokeHelper(0x35, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2267.          nDataset, sName, nNumTraces, nHistBufferSize);
  2268. }
  2269.  
  2270. void CScrollX::PrintGraph()
  2271. {
  2272.     InvokeHelper(0x36, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2273. }
  2274.  
  2275. void CScrollX::PrinterSetup()
  2276. {
  2277.     InvokeHelper(0x37, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2278. }
  2279.  
  2280. BOOL CScrollX::GetSDataSimulationMode(long nDataset)
  2281. {
  2282.     BOOL result;
  2283.     static BYTE parms[] =
  2284.         VTS_I4;
  2285.     InvokeHelper(0x96, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
  2286.         nDataset);
  2287.     return result;
  2288. }
  2289.  
  2290. void CScrollX::SetSDataSimulationMode(long nDataset, BOOL bNewValue)
  2291. {
  2292.     static BYTE parms[] =
  2293.         VTS_I4 VTS_BOOL;
  2294.     InvokeHelper(0x96, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  2295.          nDataset, bNewValue);
  2296. }
  2297.  
  2298. void CScrollX::ResetScroll(long nDataset)
  2299. {
  2300.     static BYTE parms[] =
  2301.         VTS_I4;
  2302.     InvokeHelper(0x38, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  2303.          nDataset);
  2304. }
  2305.  
  2306. BOOL CScrollX::CopyToClipboard()
  2307. {
  2308.     BOOL result;
  2309.     InvokeHelper(0x39, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  2310.     return result;
  2311. }
  2312.  
  2313. void CScrollX::AboutBox()
  2314. {
  2315.     InvokeHelper(0xfffffdd8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  2316. }
  2317.