home *** CD-ROM | disk | FTP | other *** search
/ Mastering Visual Basic 6 / mastvb6.iso / leadtools / ocx32.lt / LEADOCR.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-13  |  9.4 KB  |  475 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 "leadocr.h"
  9.  
  10. /////////////////////////////////////////////////////////////////////////////
  11. // CLeadOcr
  12.  
  13. IMPLEMENT_DYNCREATE(CLeadOcr, CWnd)
  14.  
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CLeadOcr properties
  17.  
  18. long CLeadOcr::GetPreprocessingMode()
  19. {
  20.     long result;
  21.     GetProperty(0x1, VT_I4, (void*)&result);
  22.     return result;
  23. }
  24.  
  25. void CLeadOcr::SetPreprocessingMode(long propVal)
  26. {
  27.     SetProperty(0x1, VT_I4, propVal);
  28. }
  29.  
  30. long CLeadOcr::GetRecognitionMode()
  31. {
  32.     long result;
  33.     GetProperty(0x2, VT_I4, (void*)&result);
  34.     return result;
  35. }
  36.  
  37. void CLeadOcr::SetRecognitionMode(long propVal)
  38. {
  39.     SetProperty(0x2, VT_I4, propVal);
  40. }
  41.  
  42. long CLeadOcr::GetVerifierMode()
  43. {
  44.     long result;
  45.     GetProperty(0x3, VT_I4, (void*)&result);
  46.     return result;
  47. }
  48.  
  49. void CLeadOcr::SetVerifierMode(long propVal)
  50. {
  51.     SetProperty(0x3, VT_I4, propVal);
  52. }
  53.  
  54. long CLeadOcr::GetMinPointSize()
  55. {
  56.     long result;
  57.     GetProperty(0x4, VT_I4, (void*)&result);
  58.     return result;
  59. }
  60.  
  61. void CLeadOcr::SetMinPointSize(long propVal)
  62. {
  63.     SetProperty(0x4, VT_I4, propVal);
  64. }
  65.  
  66. long CLeadOcr::GetMaxPointSize()
  67. {
  68.     long result;
  69.     GetProperty(0x5, VT_I4, (void*)&result);
  70.     return result;
  71. }
  72.  
  73. void CLeadOcr::SetMaxPointSize(long propVal)
  74. {
  75.     SetProperty(0x5, VT_I4, propVal);
  76. }
  77.  
  78. CString CLeadOcr::GetDocumentName()
  79. {
  80.     CString result;
  81.     GetProperty(0x6, VT_BSTR, (void*)&result);
  82.     return result;
  83. }
  84.  
  85. void CLeadOcr::SetDocumentName(LPCTSTR propVal)
  86. {
  87.     SetProperty(0x6, VT_BSTR, propVal);
  88. }
  89.  
  90. CString CLeadOcr::GetQuestionable()
  91. {
  92.     CString result;
  93.     GetProperty(0x7, VT_BSTR, (void*)&result);
  94.     return result;
  95. }
  96.  
  97. void CLeadOcr::SetQuestionable(LPCTSTR propVal)
  98. {
  99.     SetProperty(0x7, VT_BSTR, propVal);
  100. }
  101.  
  102. CString CLeadOcr::GetUnrecognized()
  103. {
  104.     CString result;
  105.     GetProperty(0x8, VT_BSTR, (void*)&result);
  106.     return result;
  107. }
  108.  
  109. void CLeadOcr::SetUnrecognized(LPCTSTR propVal)
  110. {
  111.     SetProperty(0x8, VT_BSTR, propVal);
  112. }
  113.  
  114. CString CLeadOcr::GetLeftSingleQuote()
  115. {
  116.     CString result;
  117.     GetProperty(0x9, VT_BSTR, (void*)&result);
  118.     return result;
  119. }
  120.  
  121. void CLeadOcr::SetLeftSingleQuote(LPCTSTR propVal)
  122. {
  123.     SetProperty(0x9, VT_BSTR, propVal);
  124. }
  125.  
  126. CString CLeadOcr::GetRightSingleQuote()
  127. {
  128.     CString result;
  129.     GetProperty(0xa, VT_BSTR, (void*)&result);
  130.     return result;
  131. }
  132.  
  133. void CLeadOcr::SetRightSingleQuote(LPCTSTR propVal)
  134. {
  135.     SetProperty(0xa, VT_BSTR, propVal);
  136. }
  137.  
  138. CString CLeadOcr::GetLeftDoubleQuote()
  139. {
  140.     CString result;
  141.     GetProperty(0xb, VT_BSTR, (void*)&result);
  142.     return result;
  143. }
  144.  
  145. void CLeadOcr::SetLeftDoubleQuote(LPCTSTR propVal)
  146. {
  147.     SetProperty(0xb, VT_BSTR, propVal);
  148. }
  149.  
  150. CString CLeadOcr::GetRightDoubleQuote()
  151. {
  152.     CString result;
  153.     GetProperty(0xc, VT_BSTR, (void*)&result);
  154.     return result;
  155. }
  156.  
  157. void CLeadOcr::SetRightDoubleQuote(LPCTSTR propVal)
  158. {
  159.     SetProperty(0xc, VT_BSTR, propVal);
  160. }
  161.  
  162. CString CLeadOcr::GetDecimal()
  163. {
  164.     CString result;
  165.     GetProperty(0xd, VT_BSTR, (void*)&result);
  166.     return result;
  167. }
  168.  
  169. void CLeadOcr::SetDecimal(LPCTSTR propVal)
  170. {
  171.     SetProperty(0xd, VT_BSTR, propVal);
  172. }
  173.  
  174. CString CLeadOcr::GetThousands()
  175. {
  176.     CString result;
  177.     GetProperty(0xe, VT_BSTR, (void*)&result);
  178.     return result;
  179. }
  180.  
  181. void CLeadOcr::SetThousands(LPCTSTR propVal)
  182. {
  183.     SetProperty(0xe, VT_BSTR, propVal);
  184. }
  185.  
  186. CString CLeadOcr::GetLexicon()
  187. {
  188.     CString result;
  189.     GetProperty(0xf, VT_BSTR, (void*)&result);
  190.     return result;
  191. }
  192.  
  193. void CLeadOcr::SetLexicon(LPCTSTR propVal)
  194. {
  195.     SetProperty(0xf, VT_BSTR, propVal);
  196. }
  197.  
  198. CString CLeadOcr::GetTraining()
  199. {
  200.     CString result;
  201.     GetProperty(0x10, VT_BSTR, (void*)&result);
  202.     return result;
  203. }
  204.  
  205. void CLeadOcr::SetTraining(LPCTSTR propVal)
  206. {
  207.     SetProperty(0x10, VT_BSTR, propVal);
  208. }
  209.  
  210. long CLeadOcr::GetLanguage()
  211. {
  212.     long result;
  213.     GetProperty(0x11, VT_I4, (void*)&result);
  214.     return result;
  215. }
  216.  
  217. void CLeadOcr::SetLanguage(long propVal)
  218. {
  219.     SetProperty(0x11, VT_I4, propVal);
  220. }
  221.  
  222. BOOL CLeadOcr::GetHeaderFooterProcess()
  223. {
  224.     BOOL result;
  225.     GetProperty(0x12, VT_BOOL, (void*)&result);
  226.     return result;
  227. }
  228.  
  229. void CLeadOcr::SetHeaderFooterProcess(BOOL propVal)
  230. {
  231.     SetProperty(0x12, VT_BOOL, propVal);
  232. }
  233.  
  234. BOOL CLeadOcr::GetSloppyManual()
  235. {
  236.     BOOL result;
  237.     GetProperty(0x13, VT_BOOL, (void*)&result);
  238.     return result;
  239. }
  240.  
  241. void CLeadOcr::SetSloppyManual(BOOL propVal)
  242. {
  243.     SetProperty(0x13, VT_BOOL, propVal);
  244. }
  245.  
  246. long CLeadOcr::GetTextOrientLimit()
  247. {
  248.     long result;
  249.     GetProperty(0x14, VT_I4, (void*)&result);
  250.     return result;
  251. }
  252.  
  253. void CLeadOcr::SetTextOrientLimit(long propVal)
  254. {
  255.     SetProperty(0x14, VT_I4, propVal);
  256. }
  257.  
  258. BOOL CLeadOcr::GetEnableRecognizeEvent()
  259. {
  260.     BOOL result;
  261.     GetProperty(0x15, VT_BOOL, (void*)&result);
  262.     return result;
  263. }
  264.  
  265. void CLeadOcr::SetEnableRecognizeEvent(BOOL propVal)
  266. {
  267.     SetProperty(0x15, VT_BOOL, propVal);
  268. }
  269.  
  270. short CLeadOcr::GetPolygonSize()
  271. {
  272.     short result;
  273.     GetProperty(0x16, VT_I2, (void*)&result);
  274.     return result;
  275. }
  276.  
  277. void CLeadOcr::SetPolygonSize(short propVal)
  278. {
  279.     SetProperty(0x16, VT_I2, propVal);
  280. }
  281.  
  282. long CLeadOcr::GetBitmap()
  283. {
  284.     long result;
  285.     GetProperty(0x17, VT_I4, (void*)&result);
  286.     return result;
  287. }
  288.  
  289. void CLeadOcr::SetBitmap(long propVal)
  290. {
  291.     SetProperty(0x17, VT_I4, propVal);
  292. }
  293.  
  294. long CLeadOcr::GetVerifierThreshold()
  295. {
  296.     long result;
  297.     GetProperty(0x18, VT_I4, (void*)&result);
  298.     return result;
  299. }
  300.  
  301. void CLeadOcr::SetVerifierThreshold(long propVal)
  302. {
  303.     SetProperty(0x18, VT_I4, propVal);
  304. }
  305.  
  306. short CLeadOcr::GetStatusRecognizeEvent()
  307. {
  308.     short result;
  309.     GetProperty(0x19, VT_I2, (void*)&result);
  310.     return result;
  311. }
  312.  
  313. void CLeadOcr::SetStatusRecognizeEvent(short propVal)
  314. {
  315.     SetProperty(0x19, VT_I2, propVal);
  316. }
  317.  
  318. BOOL CLeadOcr::GetEnableMethodErrors()
  319. {
  320.     BOOL result;
  321.     GetProperty(0x1a, VT_BOOL, (void*)&result);
  322.     return result;
  323. }
  324.  
  325. void CLeadOcr::SetEnableMethodErrors(BOOL propVal)
  326. {
  327.     SetProperty(0x1a, VT_BOOL, propVal);
  328. }
  329.  
  330. CString CLeadOcr::GetTextRecognizeEvent()
  331. {
  332.     CString result;
  333.     GetProperty(0x1b, VT_BSTR, (void*)&result);
  334.     return result;
  335. }
  336.  
  337. void CLeadOcr::SetTextRecognizeEvent(LPCTSTR propVal)
  338. {
  339.     SetProperty(0x1b, VT_BSTR, propVal);
  340. }
  341.  
  342. /////////////////////////////////////////////////////////////////////////////
  343. // CLeadOcr operations
  344.  
  345. short CLeadOcr::SaveDoc(LPCTSTR pszFile, short nFormat)
  346. {
  347.     short result;
  348.     static BYTE parms[] =
  349.         VTS_BSTR VTS_I2;
  350.     InvokeHelper(0x1c, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  351.         pszFile, nFormat);
  352.     return result;
  353. }
  354.  
  355. short CLeadOcr::EditDoc()
  356. {
  357.     short result;
  358.     InvokeHelper(0x1d, DISPATCH_METHOD, VT_I2, (void*)&result, NULL);
  359.     return result;
  360. }
  361.  
  362. long CLeadOcr::GetPolygonX(short nIndex)
  363. {
  364.     long result;
  365.     static BYTE parms[] =
  366.         VTS_I2;
  367.     InvokeHelper(0x26, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  368.         nIndex);
  369.     return result;
  370. }
  371.  
  372. void CLeadOcr::SetPolygonX(short nIndex, long nNewValue)
  373. {
  374.     static BYTE parms[] =
  375.         VTS_I2 VTS_I4;
  376.     InvokeHelper(0x26, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  377.          nIndex, nNewValue);
  378. }
  379.  
  380. long CLeadOcr::GetPolygonY(short nIndex)
  381. {
  382.     long result;
  383.     static BYTE parms[] =
  384.         VTS_I2;
  385.     InvokeHelper(0x27, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, parms,
  386.         nIndex);
  387.     return result;
  388. }
  389.  
  390. void CLeadOcr::SetPolygonY(short nIndex, long nNewValue)
  391. {
  392.     static BYTE parms[] =
  393.         VTS_I2 VTS_I4;
  394.     InvokeHelper(0x27, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  395.          nIndex, nNewValue);
  396. }
  397.  
  398. void CLeadOcr::ClearDoc()
  399. {
  400.     InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  401. }
  402.  
  403. short CLeadOcr::InfoDoc(short* nNbPages)
  404. {
  405.     short result;
  406.     static BYTE parms[] =
  407.         VTS_PI2;
  408.     InvokeHelper(0x1f, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  409.         nNbPages);
  410.     return result;
  411. }
  412.  
  413. short CLeadOcr::InfoPage(short nPage, short* nNbZones)
  414. {
  415.     short result;
  416.     static BYTE parms[] =
  417.         VTS_I2 VTS_PI2;
  418.     InvokeHelper(0x20, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  419.         nPage, nNbZones);
  420.     return result;
  421. }
  422.  
  423. short CLeadOcr::InfoZone(short nPage, short nZone, short* nType, short* nLeft, short* nTop, short* nWidth, short* nHeight)
  424. {
  425.     short result;
  426.     static BYTE parms[] =
  427.         VTS_I2 VTS_I2 VTS_PI2 VTS_PI2 VTS_PI2 VTS_PI2 VTS_PI2;
  428.     InvokeHelper(0x21, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  429.         nPage, nZone, nType, nLeft, nTop, nWidth, nHeight);
  430.     return result;
  431. }
  432.  
  433. short CLeadOcr::SetZone(short nZone, short nType, long nLanguage, long nLexiconClass, long nUserLexicon, short nLexiconMode, short nStacking)
  434. {
  435.     short result;
  436.     static BYTE parms[] =
  437.         VTS_I2 VTS_I2 VTS_I4 VTS_I4 VTS_I4 VTS_I2 VTS_I2;
  438.     InvokeHelper(0x22, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  439.         nZone, nType, nLanguage, nLexiconClass, nUserLexicon, nLexiconMode, nStacking);
  440.     return result;
  441. }
  442.  
  443. void CLeadOcr::UnlockSupport(short iType, LPCTSTR pszKey)
  444. {
  445.     static BYTE parms[] =
  446.         VTS_I2 VTS_BSTR;
  447.     InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  448.          iType, pszKey);
  449. }
  450.  
  451. BOOL CLeadOcr::IsSupportLocked(short iType)
  452. {
  453.     BOOL result;
  454.     static BYTE parms[] =
  455.         VTS_I2;
  456.     InvokeHelper(0x24, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  457.         iType);
  458.     return result;
  459. }
  460.  
  461. short CLeadOcr::RecognizeOCR(short nFlags)
  462. {
  463.     short result;
  464.     static BYTE parms[] =
  465.         VTS_I2;
  466.     InvokeHelper(0x25, DISPATCH_METHOD, VT_I2, (void*)&result, parms,
  467.         nFlags);
  468.     return result;
  469. }
  470.  
  471. void CLeadOcr::AboutBox()
  472. {
  473.     InvokeHelper(0xfffffdd8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  474. }
  475.