home *** CD-ROM | disk | FTP | other *** search
/ Mastering Visual Basic 6 / mastvb6.iso / leadtools / ocx32.lt / leadscr.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-07-02  |  21.0 KB  |  922 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 "leadscr.h"
  9.  
  10. // Dispatch interfaces referenced by this interface
  11. #include "picture.h"
  12.  
  13. /////////////////////////////////////////////////////////////////////////////
  14. // CLeadScr
  15.  
  16. IMPLEMENT_DYNCREATE(CLeadScr, CWnd)
  17.  
  18. /////////////////////////////////////////////////////////////////////////////
  19. // CLeadScr properties
  20.  
  21. /////////////////////////////////////////////////////////////////////////////
  22. // CLeadScr operations
  23.  
  24. unsigned long CLeadScr::AddRef()
  25. {
  26.     unsigned long result;
  27.     InvokeHelper(0x60000001, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  28.     return result;
  29. }
  30.  
  31. unsigned long CLeadScr::Release()
  32. {
  33.     unsigned long result;
  34.     InvokeHelper(0x60000002, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  35.     return result;
  36. }
  37.  
  38. BOOL CLeadScr::GetEnableMethodErrors()
  39. {
  40.     BOOL result;
  41.     InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  42.     return result;
  43. }
  44.  
  45. void CLeadScr::SetEnableMethodErrors(BOOL bNewValue)
  46. {
  47.     static BYTE parms[] =
  48.         VTS_BOOL;
  49.     InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  50.          bNewValue);
  51. }
  52.  
  53. short CLeadScr::GetScaleMode()
  54. {
  55.     short result;
  56.     InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  57.     return result;
  58. }
  59.  
  60. void CLeadScr::SetScaleMode(short nNewValue)
  61. {
  62.     static BYTE parms[] =
  63.         VTS_I2;
  64.     InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  65.          nNewValue);
  66. }
  67.  
  68. short CLeadScr::GetCaptureCursorIndex()
  69. {
  70.     short result;
  71.     InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  72.     return result;
  73. }
  74.  
  75. void CLeadScr::SetCaptureCursorIndex(short nNewValue)
  76. {
  77.     static BYTE parms[] =
  78.         VTS_I2;
  79.     InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  80.          nNewValue);
  81. }
  82.  
  83. short CLeadScr::GetCaptureStatusCursorIndex()
  84. {
  85.     short result;
  86.     InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  87.     return result;
  88. }
  89.  
  90. void CLeadScr::SetCaptureStatusCursorIndex(short nNewValue)
  91. {
  92.     static BYTE parms[] =
  93.         VTS_I2;
  94.     InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  95.          nNewValue);
  96. }
  97.  
  98. short CLeadScr::GetCaptureAreaDrawCursorIndex()
  99. {
  100.     short result;
  101.     InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  102.     return result;
  103. }
  104.  
  105. void CLeadScr::SetCaptureAreaDrawCursorIndex(short nNewValue)
  106. {
  107.     static BYTE parms[] =
  108.         VTS_I2;
  109.     InvokeHelper(0x1d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  110.          nNewValue);
  111. }
  112.  
  113. short CLeadScr::GetCaptureObjectSelectCursorIndex()
  114. {
  115.     short result;
  116.     InvokeHelper(0x32, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  117.     return result;
  118. }
  119.  
  120. void CLeadScr::SetCaptureObjectSelectCursorIndex(short nNewValue)
  121. {
  122.     static BYTE parms[] =
  123.         VTS_I2;
  124.     InvokeHelper(0x32, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  125.          nNewValue);
  126. }
  127.  
  128. CPicture CLeadScr::GetCaptureCursor()
  129. {
  130.     LPDISPATCH pDispatch;
  131.     InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  132.     return CPicture(pDispatch);
  133. }
  134.  
  135. void CLeadScr::SetCaptureCursor(LPDISPATCH newValue)
  136. {
  137.     static BYTE parms[] =
  138.         VTS_DISPATCH;
  139.     InvokeHelper(0x4, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  140.          newValue);
  141. }
  142.  
  143. CPicture CLeadScr::GetCaptureStatusCursor()
  144. {
  145.     LPDISPATCH pDispatch;
  146.     InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  147.     return CPicture(pDispatch);
  148. }
  149.  
  150. void CLeadScr::SetCaptureStatusCursor(LPDISPATCH newValue)
  151. {
  152.     static BYTE parms[] =
  153.         VTS_DISPATCH;
  154.     InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  155.          newValue);
  156. }
  157.  
  158. CPicture CLeadScr::GetCaptureAreaDrawCursor()
  159. {
  160.     LPDISPATCH pDispatch;
  161.     InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  162.     return CPicture(pDispatch);
  163. }
  164.  
  165. void CLeadScr::SetCaptureAreaDrawCursor(LPDISPATCH newValue)
  166. {
  167.     static BYTE parms[] =
  168.         VTS_DISPATCH;
  169.     InvokeHelper(0x1e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  170.          newValue);
  171. }
  172.  
  173. CPicture CLeadScr::GetCaptureObjectSelectCursor()
  174. {
  175.     LPDISPATCH pDispatch;
  176.     InvokeHelper(0x33, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  177.     return CPicture(pDispatch);
  178. }
  179.  
  180. void CLeadScr::SetCaptureObjectSelectCursor(LPDISPATCH newValue)
  181. {
  182.     static BYTE parms[] =
  183.         VTS_DISPATCH;
  184.     InvokeHelper(0x33, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  185.          newValue);
  186. }
  187.  
  188. short CLeadScr::GetCaptureHotKey()
  189. {
  190.     short result;
  191.     InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  192.     return result;
  193. }
  194.  
  195. void CLeadScr::SetCaptureHotKey(short nNewValue)
  196. {
  197.     static BYTE parms[] =
  198.         VTS_I2;
  199.     InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  200.          nNewValue);
  201. }
  202.  
  203. short CLeadScr::GetCaptureHotKeyModifiers()
  204. {
  205.     short result;
  206.     InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  207.     return result;
  208. }
  209.  
  210. void CLeadScr::SetCaptureHotKeyModifiers(short nNewValue)
  211. {
  212.     static BYTE parms[] =
  213.         VTS_I2;
  214.     InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  215.          nNewValue);
  216. }
  217.  
  218. short CLeadScr::GetCaptureCancelKey()
  219. {
  220.     short result;
  221.     InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  222.     return result;
  223. }
  224.  
  225. void CLeadScr::SetCaptureCancelKey(short nNewValue)
  226. {
  227.     static BYTE parms[] =
  228.         VTS_I2;
  229.     InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  230.          nNewValue);
  231. }
  232.  
  233. long CLeadScr::GetCaptureDelay()
  234. {
  235.     long result;
  236.     InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  237.     return result;
  238. }
  239.  
  240. void CLeadScr::SetCaptureDelay(long nNewValue)
  241. {
  242.     static BYTE parms[] =
  243.         VTS_I4;
  244.     InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  245.          nNewValue);
  246. }
  247.  
  248. short CLeadScr::GetCaptureCount()
  249. {
  250.     short result;
  251.     InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  252.     return result;
  253. }
  254.  
  255. void CLeadScr::SetCaptureCount(short nNewValue)
  256. {
  257.     static BYTE parms[] =
  258.         VTS_I2;
  259.     InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  260.          nNewValue);
  261. }
  262.  
  263. long CLeadScr::GetCaptureInterval()
  264. {
  265.     long result;
  266.     InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  267.     return result;
  268. }
  269.  
  270. void CLeadScr::SetCaptureInterval(long nNewValue)
  271. {
  272.     static BYTE parms[] =
  273.         VTS_I4;
  274.     InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  275.          nNewValue);
  276. }
  277.  
  278. long CLeadScr::GetCaptureInfohWnd()
  279. {
  280.     long result;
  281.     InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  282.     return result;
  283. }
  284.  
  285. float CLeadScr::GetCaptureInfoTop()
  286. {
  287.     float result;
  288.     InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  289.     return result;
  290. }
  291.  
  292. float CLeadScr::GetCaptureInfoLeft()
  293. {
  294.     float result;
  295.     InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  296.     return result;
  297. }
  298.  
  299. float CLeadScr::GetCaptureInfoWidth()
  300. {
  301.     float result;
  302.     InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  303.     return result;
  304. }
  305.  
  306. float CLeadScr::GetCaptureInfoHeight()
  307. {
  308.     float result;
  309.     InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  310.     return result;
  311. }
  312.  
  313. long CLeadScr::GetCaptureInfoResType()
  314. {
  315.     long result;
  316.     InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  317.     return result;
  318. }
  319.  
  320. long CLeadScr::GetCaptureInfoResIndex()
  321. {
  322.     long result;
  323.     InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  324.     return result;
  325. }
  326.  
  327. CString CLeadScr::GetCaptureInfoResourceId()
  328. {
  329.     CString result;
  330.     InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  331.     return result;
  332. }
  333.  
  334. CString CLeadScr::GetCaptureInfoExeName()
  335. {
  336.     CString result;
  337.     InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  338.     return result;
  339. }
  340.  
  341. short CLeadScr::GetCaptureAreaFillPattern()
  342. {
  343.     short result;
  344.     InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  345.     return result;
  346. }
  347.  
  348. void CLeadScr::SetCaptureAreaFillPattern(short nNewValue)
  349. {
  350.     static BYTE parms[] =
  351.         VTS_I2;
  352.     InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  353.          nNewValue);
  354. }
  355.  
  356. short CLeadScr::GetCaptureAreaDrawLineStyle()
  357. {
  358.     short result;
  359.     InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  360.     return result;
  361. }
  362.  
  363. void CLeadScr::SetCaptureAreaDrawLineStyle(short nNewValue)
  364. {
  365.     static BYTE parms[] =
  366.         VTS_I2;
  367.     InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  368.          nNewValue);
  369. }
  370.  
  371. float CLeadScr::GetCaptureAreaDrawEllipseWidth()
  372. {
  373.     float result;
  374.     InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  375.     return result;
  376. }
  377.  
  378. void CLeadScr::SetCaptureAreaDrawEllipseWidth(float newValue)
  379. {
  380.     static BYTE parms[] =
  381.         VTS_R4;
  382.     InvokeHelper(0x1b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  383.          newValue);
  384. }
  385.  
  386. float CLeadScr::GetCaptureAreaDrawEllipseHeight()
  387. {
  388.     float result;
  389.     InvokeHelper(0x1c, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  390.     return result;
  391. }
  392.  
  393. void CLeadScr::SetCaptureAreaDrawEllipseHeight(float newValue)
  394. {
  395.     static BYTE parms[] =
  396.         VTS_R4;
  397.     InvokeHelper(0x1c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  398.          newValue);
  399. }
  400.  
  401. float CLeadScr::GetCaptureAreaInfoLeft()
  402. {
  403.     float result;
  404.     InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  405.     return result;
  406. }
  407.  
  408. void CLeadScr::SetCaptureAreaInfoLeft(float newValue)
  409. {
  410.     static BYTE parms[] =
  411.         VTS_R4;
  412.     InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  413.          newValue);
  414. }
  415.  
  416. float CLeadScr::GetCaptureAreaInfoTop()
  417. {
  418.     float result;
  419.     InvokeHelper(0x22, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  420.     return result;
  421. }
  422.  
  423. void CLeadScr::SetCaptureAreaInfoTop(float newValue)
  424. {
  425.     static BYTE parms[] =
  426.         VTS_R4;
  427.     InvokeHelper(0x22, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  428.          newValue);
  429. }
  430.  
  431. float CLeadScr::GetCaptureAreaInfoWidth()
  432. {
  433.     float result;
  434.     InvokeHelper(0x23, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  435.     return result;
  436. }
  437.  
  438. void CLeadScr::SetCaptureAreaInfoWidth(float newValue)
  439. {
  440.     static BYTE parms[] =
  441.         VTS_R4;
  442.     InvokeHelper(0x23, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  443.          newValue);
  444. }
  445.  
  446. BOOL CLeadScr::GetCaptureAreaShowDrawCursor()
  447. {
  448.     BOOL result;
  449.     InvokeHelper(0x25, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  450.     return result;
  451. }
  452.  
  453. void CLeadScr::SetCaptureAreaShowDrawCursor(BOOL bNewValue)
  454. {
  455.     static BYTE parms[] =
  456.         VTS_BOOL;
  457.     InvokeHelper(0x25, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  458.          bNewValue);
  459. }
  460.  
  461. BOOL CLeadScr::GetCaptureAreaIncludeCursor()
  462. {
  463.     BOOL result;
  464.     InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  465.     return result;
  466. }
  467.  
  468. void CLeadScr::SetCaptureAreaIncludeCursor(BOOL bNewValue)
  469. {
  470.     static BYTE parms[] =
  471.         VTS_BOOL;
  472.     InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  473.          bNewValue);
  474. }
  475.  
  476. float CLeadScr::GetCaptureAreaInfoHeight()
  477. {
  478.     float result;
  479.     InvokeHelper(0x24, DISPATCH_PROPERTYGET, VT_R4, (void*)&result, NULL);
  480.     return result;
  481. }
  482.  
  483. void CLeadScr::SetCaptureAreaInfoHeight(float newValue)
  484. {
  485.     static BYTE parms[] =
  486.         VTS_R4;
  487.     InvokeHelper(0x24, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  488.          newValue);
  489. }
  490.  
  491. BOOL CLeadScr::GetCaptureAreaEnableKeyboard()
  492. {
  493.     BOOL result;
  494.     InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  495.     return result;
  496. }
  497.  
  498. void CLeadScr::SetCaptureAreaEnableKeyboard(BOOL bNewValue)
  499. {
  500.     static BYTE parms[] =
  501.         VTS_BOOL;
  502.     InvokeHelper(0x27, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  503.          bNewValue);
  504. }
  505.  
  506. BOOL CLeadScr::GetCaptureAreaShowOpaqueText()
  507. {
  508.     BOOL result;
  509.     InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  510.     return result;
  511. }
  512.  
  513. void CLeadScr::SetCaptureAreaShowOpaqueText(BOOL bNewValue)
  514. {
  515.     static BYTE parms[] =
  516.         VTS_BOOL;
  517.     InvokeHelper(0x28, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  518.          bNewValue);
  519. }
  520.  
  521. BOOL CLeadScr::GetCaptureAreaShowCursorPosition()
  522. {
  523.     BOOL result;
  524.     InvokeHelper(0x29, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  525.     return result;
  526. }
  527.  
  528. void CLeadScr::SetCaptureAreaShowCursorPosition(BOOL bNewValue)
  529. {
  530.     static BYTE parms[] =
  531.         VTS_BOOL;
  532.     InvokeHelper(0x29, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  533.          bNewValue);
  534. }
  535.  
  536. BOOL CLeadScr::GetCaptureAreaShowAreaSize()
  537. {
  538.     BOOL result;
  539.     InvokeHelper(0x2a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  540.     return result;
  541. }
  542.  
  543. void CLeadScr::SetCaptureAreaShowAreaSize(BOOL bNewValue)
  544. {
  545.     static BYTE parms[] =
  546.         VTS_BOOL;
  547.     InvokeHelper(0x2a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  548.          bNewValue);
  549. }
  550.  
  551. BOOL CLeadScr::GetCaptureAreaShowInfoWindow()
  552. {
  553.     BOOL result;
  554.     InvokeHelper(0x2b, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  555.     return result;
  556. }
  557.  
  558. void CLeadScr::SetCaptureAreaShowInfoWindow(BOOL bNewValue)
  559. {
  560.     static BYTE parms[] =
  561.         VTS_BOOL;
  562.     InvokeHelper(0x2b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  563.          bNewValue);
  564. }
  565.  
  566. BOOL CLeadScr::GetCaptureAreaSensitiveInfoWindow()
  567. {
  568.     BOOL result;
  569.     InvokeHelper(0x2c, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  570.     return result;
  571. }
  572.  
  573. void CLeadScr::SetCaptureAreaSensitiveInfoWindow(BOOL bNewValue)
  574. {
  575.     static BYTE parms[] =
  576.         VTS_BOOL;
  577.     InvokeHelper(0x2c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  578.          bNewValue);
  579. }
  580.  
  581. BOOL CLeadScr::GetCaptureAreaBitmapWithRegion()
  582. {
  583.     BOOL result;
  584.     InvokeHelper(0x2d, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  585.     return result;
  586. }
  587.  
  588. void CLeadScr::SetCaptureAreaBitmapWithRegion(BOOL bNewValue)
  589. {
  590.     static BYTE parms[] =
  591.         VTS_BOOL;
  592.     InvokeHelper(0x2d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  593.          bNewValue);
  594. }
  595.  
  596. short CLeadScr::GetCaptureAreaZoomFactor()
  597. {
  598.     short result;
  599.     InvokeHelper(0x2e, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  600.     return result;
  601. }
  602.  
  603. void CLeadScr::SetCaptureAreaZoomFactor(short nNewValue)
  604. {
  605.     static BYTE parms[] =
  606.         VTS_I2;
  607.     InvokeHelper(0x2e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  608.          nNewValue);
  609. }
  610.  
  611. BOOL CLeadScr::GetCaptureObjectInvert()
  612. {
  613.     BOOL result;
  614.     InvokeHelper(0x2f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  615.     return result;
  616. }
  617.  
  618. void CLeadScr::SetCaptureObjectInvert(BOOL bNewValue)
  619. {
  620.     static BYTE parms[] =
  621.         VTS_BOOL;
  622.     InvokeHelper(0x2f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  623.          bNewValue);
  624. }
  625.  
  626. BOOL CLeadScr::GetCaptureObjectEnableKeyboard()
  627. {
  628.     BOOL result;
  629.     InvokeHelper(0x30, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  630.     return result;
  631. }
  632.  
  633. void CLeadScr::SetCaptureObjectEnableKeyboard(BOOL bNewValue)
  634. {
  635.     static BYTE parms[] =
  636.         VTS_BOOL;
  637.     InvokeHelper(0x30, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  638.          bNewValue);
  639. }
  640.  
  641. short CLeadScr::GetCaptureObjectBorderWidth()
  642. {
  643.     short result;
  644.     InvokeHelper(0x31, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  645.     return result;
  646. }
  647.  
  648. void CLeadScr::SetCaptureObjectBorderWidth(short nNewValue)
  649. {
  650.     static BYTE parms[] =
  651.         VTS_I2;
  652.     InvokeHelper(0x31, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  653.          nNewValue);
  654. }
  655.  
  656. long CLeadScr::GetBitmap()
  657. {
  658.     long result;
  659.     InvokeHelper(0x34, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  660.     return result;
  661. }
  662.  
  663. unsigned long CLeadScr::GetCaptureAreaFillForeColor()
  664. {
  665.     unsigned long result;
  666.     InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  667.     return result;
  668. }
  669.  
  670. void CLeadScr::SetCaptureAreaFillForeColor(unsigned long newValue)
  671. {
  672.     static BYTE parms[] =
  673.         VTS_I4;
  674.     InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  675.          newValue);
  676. }
  677.  
  678. unsigned long CLeadScr::GetCaptureAreaFillBackColor()
  679. {
  680.     unsigned long result;
  681.     InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  682.     return result;
  683. }
  684.  
  685. void CLeadScr::SetCaptureAreaFillBackColor(unsigned long newValue)
  686. {
  687.     static BYTE parms[] =
  688.         VTS_I4;
  689.     InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  690.          newValue);
  691. }
  692.  
  693. unsigned long CLeadScr::GetCaptureAreaDrawLineColor()
  694. {
  695.     unsigned long result;
  696.     InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  697.     return result;
  698. }
  699.  
  700. void CLeadScr::SetCaptureAreaDrawLineColor(unsigned long newValue)
  701. {
  702.     static BYTE parms[] =
  703.         VTS_I4;
  704.     InvokeHelper(0x1a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  705.          newValue);
  706. }
  707.  
  708. unsigned long CLeadScr::GetCaptureAreaTextForeColor()
  709. {
  710.     unsigned long result;
  711.     InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  712.     return result;
  713. }
  714.  
  715. void CLeadScr::SetCaptureAreaTextForeColor(unsigned long newValue)
  716. {
  717.     static BYTE parms[] =
  718.         VTS_I4;
  719.     InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  720.          newValue);
  721. }
  722.  
  723. unsigned long CLeadScr::GetCaptureAreaTextBackColor()
  724. {
  725.     unsigned long result;
  726.     InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  727.     return result;
  728. }
  729.  
  730. void CLeadScr::SetCaptureAreaTextBackColor(unsigned long newValue)
  731. {
  732.     static BYTE parms[] =
  733.         VTS_I4;
  734.     InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  735.          newValue);
  736. }
  737.  
  738. unsigned long CLeadScr::GetTransparentColor()
  739. {
  740.     unsigned long result;
  741.     InvokeHelper(0x35, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  742.     return result;
  743. }
  744.  
  745. void CLeadScr::SetTransparentColor(unsigned long newValue)
  746. {
  747.     static BYTE parms[] =
  748.         VTS_I4;
  749.     InvokeHelper(0x35, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  750.          newValue);
  751. }
  752.  
  753. short CLeadScr::GetCaptureAreaType()
  754. {
  755.     short result;
  756.     InvokeHelper(0x36, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  757.     return result;
  758. }
  759.  
  760. BOOL CLeadScr::GetCaptureAreaUseCrossLinesCursor()
  761. {
  762.     BOOL result;
  763.     InvokeHelper(0x75, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  764.     return result;
  765. }
  766.  
  767. void CLeadScr::SetCaptureAreaUseCrossLinesCursor(BOOL bNewValue)
  768. {
  769.     static BYTE parms[] =
  770.         VTS_BOOL;
  771.     InvokeHelper(0x75, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  772.          bNewValue);
  773. }
  774.  
  775. short CLeadScr::CaptureActiveWindow()
  776. {
  777.     short result;
  778.     InvokeHelper(0x64, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  779.     return result;
  780. }
  781.  
  782. short CLeadScr::CaptureActiveClient()
  783. {
  784.     short result;
  785.     InvokeHelper(0x65, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  786.     return result;
  787. }
  788.  
  789. short CLeadScr::CaptureFullScreen()
  790. {
  791.     short result;
  792.     InvokeHelper(0x66, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  793.     return result;
  794. }
  795.  
  796. short CLeadScr::CaptureMenuUnderCursor()
  797. {
  798.     short result;
  799.     InvokeHelper(0x67, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  800.     return result;
  801. }
  802.  
  803. short CLeadScr::CaptureSelectedObject()
  804. {
  805.     short result;
  806.     InvokeHelper(0x68, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  807.     return result;
  808. }
  809.  
  810. short CLeadScr::CaptureArea(short AreaType)
  811. {
  812.     short result;
  813.     static BYTE parms[] =
  814.         VTS_I2;
  815.     InvokeHelper(0x69, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  816.         AreaType);
  817.     return result;
  818. }
  819.  
  820. short CLeadScr::CaptureMouseCursor()
  821. {
  822.     short result;
  823.     InvokeHelper(0x6a, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  824.     return result;
  825. }
  826.  
  827. short CLeadScr::CaptureOptionDlg(long hwndParent)
  828. {
  829.     short result;
  830.     static BYTE parms[] =
  831.         VTS_I4;
  832.     InvokeHelper(0x6b, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  833.         hwndParent);
  834.     return result;
  835. }
  836.  
  837. short CLeadScr::CaptureAreaOptionDlg(long hwndParent)
  838. {
  839.     short result;
  840.     static BYTE parms[] =
  841.         VTS_I4;
  842.     InvokeHelper(0x6c, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  843.         hwndParent);
  844.     return result;
  845. }
  846.  
  847. short CLeadScr::CaptureObjectOptionDlg(long hwndParent)
  848. {
  849.     short result;
  850.     static BYTE parms[] =
  851.         VTS_I4;
  852.     InvokeHelper(0x6d, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  853.         hwndParent);
  854.     return result;
  855. }
  856.  
  857. short CLeadScr::CaptureEXEDlg(long hwndParent, LPCTSTR FileName, short ResourceType, short DialogType)
  858. {
  859.     short result;
  860.     static BYTE parms[] =
  861.         VTS_I4 VTS_BSTR VTS_I2 VTS_I2;
  862.     InvokeHelper(0x6e, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  863.         hwndParent, FileName, ResourceType, DialogType);
  864.     return result;
  865. }
  866.  
  867. short CLeadScr::CaptureGetResourceCount(LPCTSTR FileName, short nResourceType, short* pCount)
  868. {
  869.     short result;
  870.     static BYTE parms[] =
  871.         VTS_BSTR VTS_I2 VTS_PI2;
  872.     InvokeHelper(0x6f, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  873.         FileName, nResourceType, pCount);
  874.     return result;
  875. }
  876.  
  877. short CLeadScr::CaptureEXE(LPCTSTR FileName, long ResourceType, LPCTSTR ResourceID, long bIsNumberResourceID, long bCaptureByIndex)
  878. {
  879.     short result;
  880.     static BYTE parms[] =
  881.         VTS_BSTR VTS_I4 VTS_BSTR VTS_I4 VTS_I4;
  882.     InvokeHelper(0x70, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  883.         FileName, ResourceType, ResourceID, bIsNumberResourceID, bCaptureByIndex);
  884.     return result;
  885. }
  886.  
  887. short CLeadScr::CaptureWallPaper()
  888. {
  889.     short result;
  890.     InvokeHelper(0x71, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  891.     return result;
  892. }
  893.  
  894. short CLeadScr::CaptureWindowUnderCursor()
  895. {
  896.     short result;
  897.     InvokeHelper(0x72, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  898.     return result;
  899. }
  900.  
  901. void CLeadScr::ResetAreaOptions()
  902. {
  903.     InvokeHelper(0x73, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  904. }
  905.  
  906. void CLeadScr::ResetObjectOptions()
  907. {
  908.     InvokeHelper(0x74, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  909. }
  910.  
  911. void CLeadScr::StopCapture()
  912. {
  913.     InvokeHelper(0x76, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  914. }
  915.  
  916. BOOL CLeadScr::IsCaptureActive()
  917. {
  918.     BOOL result;
  919.     InvokeHelper(0x77, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  920.     return result;
  921. }
  922.