RDC.CPP
上传用户:bangxh
上传日期:2007-01-31
资源大小:42235k
文件大小:12k
源码类别:

Windows编程

开发平台:

Visual C++

  1. // Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
  2. // NOTE: Do not modify the contents of this file.  If this class is regenerated by
  3. //  Microsoft Visual C++, your modifications will be overwritten.
  4. #include "stdafx.h"
  5. #include "rdc.h"
  6. // Dispatch interfaces referenced by this interface
  7. #include "rdoReslt.h"
  8. /////////////////////////////////////////////////////////////////////////////
  9. // CRdc
  10. IMPLEMENT_DYNCREATE(CRdc, CWnd)
  11. /////////////////////////////////////////////////////////////////////////////
  12. // CRdc properties
  13. /////////////////////////////////////////////////////////////////////////////
  14. // CRdc operations
  15. CString CRdc::GetDataSourceName()
  16. {
  17. CString result;
  18. InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  19. return result;
  20. }
  21. void CRdc::SetDataSourceName(LPCTSTR lpszNewValue)
  22. {
  23. static BYTE parms[] =
  24. VTS_BSTR;
  25. InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  26.  lpszNewValue);
  27. }
  28. CString CRdc::GetSql()
  29. {
  30. CString result;
  31. InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  32. return result;
  33. }
  34. void CRdc::SetSql(LPCTSTR lpszNewValue)
  35. {
  36. static BYTE parms[] =
  37. VTS_BSTR;
  38. InvokeHelper(0x2, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  39.  lpszNewValue);
  40. }
  41. long CRdc::GetLoginTimeout()
  42. {
  43. long result;
  44. InvokeHelper(0x3, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  45. return result;
  46. }
  47. void CRdc::SetLoginTimeout(long nNewValue)
  48. {
  49. static BYTE parms[] =
  50. VTS_I4;
  51. InvokeHelper(0x3, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  52.  nNewValue);
  53. }
  54. CString CRdc::GetVersion()
  55. {
  56. CString result;
  57. InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  58. return result;
  59. }
  60. CString CRdc::GetConnect()
  61. {
  62. CString result;
  63. InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  64. return result;
  65. }
  66. void CRdc::SetConnect(LPCTSTR lpszNewValue)
  67. {
  68. static BYTE parms[] =
  69. VTS_BSTR;
  70. InvokeHelper(0x5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  71.  lpszNewValue);
  72. }
  73. long CRdc::GetQueryTimeout()
  74. {
  75. long result;
  76. InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  77. return result;
  78. }
  79. void CRdc::SetQueryTimeout(long nNewValue)
  80. {
  81. static BYTE parms[] =
  82. VTS_I4;
  83. InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  84.  nNewValue);
  85. }
  86. long CRdc::GetRowsetSize()
  87. {
  88. long result;
  89. InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  90. return result;
  91. }
  92. void CRdc::SetRowsetSize(long nNewValue)
  93. {
  94. static BYTE parms[] =
  95. VTS_I4;
  96. InvokeHelper(0x7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  97.  nNewValue);
  98. }
  99. long CRdc::GetResultsetType()
  100. {
  101. long result;
  102. InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  103. return result;
  104. }
  105. void CRdc::SetResultsetType(long nNewValue)
  106. {
  107. static BYTE parms[] =
  108. VTS_I4;
  109. InvokeHelper(0x8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  110.  nNewValue);
  111. }
  112. long CRdc::GetMaxRows()
  113. {
  114. long result;
  115. InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  116. return result;
  117. }
  118. void CRdc::SetMaxRows(long nNewValue)
  119. {
  120. static BYTE parms[] =
  121. VTS_I4;
  122. InvokeHelper(0x9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  123.  nNewValue);
  124. }
  125. CString CRdc::GetLogMessages()
  126. {
  127. CString result;
  128. InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  129. return result;
  130. }
  131. void CRdc::SetLogMessages(LPCTSTR lpszNewValue)
  132. {
  133. static BYTE parms[] =
  134. VTS_BSTR;
  135. InvokeHelper(0xa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  136.  lpszNewValue);
  137. }
  138. long CRdc::GetKeysetSize()
  139. {
  140. long result;
  141. InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  142. return result;
  143. }
  144. void CRdc::SetKeysetSize(long nNewValue)
  145. {
  146. static BYTE parms[] =
  147. VTS_I4;
  148. InvokeHelper(0xb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  149.  nNewValue);
  150. }
  151. short CRdc::GetEditMode()
  152. {
  153. short result;
  154. InvokeHelper(0xc, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  155. return result;
  156. }
  157. void CRdc::SetEditMode(short nNewValue)
  158. {
  159. static BYTE parms[] =
  160. VTS_I2;
  161. InvokeHelper(0xc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  162.  nNewValue);
  163. }
  164. BOOL CRdc::GetEnabled()
  165. {
  166. BOOL result;
  167. InvokeHelper(DISPID_ENABLED, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  168. return result;
  169. }
  170. void CRdc::SetEnabled(BOOL bNewValue)
  171. {
  172. static BYTE parms[] =
  173. VTS_BOOL;
  174. InvokeHelper(DISPID_ENABLED, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  175.  bNewValue);
  176. }
  177. CrdoResultset CRdc::GetResultset()
  178. {
  179. LPDISPATCH pDispatch;
  180. InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
  181. return CrdoResultset(pDispatch);
  182. }
  183. void CRdc::SetRefResultset(LPDISPATCH newValue)
  184. {
  185. static BYTE parms[] =
  186. VTS_DISPATCH;
  187. InvokeHelper(0xd, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  188.  newValue);
  189. }
  190. BOOL CRdc::GetReadOnly()
  191. {
  192. BOOL result;
  193. InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
  194. return result;
  195. }
  196. void CRdc::SetReadOnly(BOOL bNewValue)
  197. {
  198. static BYTE parms[] =
  199. VTS_BOOL;
  200. InvokeHelper(0xe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  201.  bNewValue);
  202. }
  203. short CRdc::GetOptions()
  204. {
  205. short result;
  206. InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  207. return result;
  208. }
  209. void CRdc::SetOptions(short nNewValue)
  210. {
  211. static BYTE parms[] =
  212. VTS_I2;
  213. InvokeHelper(0xf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  214.  nNewValue);
  215. }
  216. CString CRdc::GetUserName_()
  217. {
  218. CString result;
  219. InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  220. return result;
  221. }
  222. void CRdc::SetUserName(LPCTSTR lpszNewValue)
  223. {
  224. static BYTE parms[] =
  225. VTS_BSTR;
  226. InvokeHelper(0x10, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  227.  lpszNewValue);
  228. }
  229. CString CRdc::GetPassword()
  230. {
  231. CString result;
  232. InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  233. return result;
  234. }
  235. void CRdc::SetPassword(LPCTSTR lpszNewValue)
  236. {
  237. static BYTE parms[] =
  238. VTS_BSTR;
  239. InvokeHelper(0x11, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  240.  lpszNewValue);
  241. }
  242. long CRdc::GetCursorDriver()
  243. {
  244. long result;
  245. InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  246. return result;
  247. }
  248. void CRdc::SetCursorDriver(long nNewValue)
  249. {
  250. static BYTE parms[] =
  251. VTS_I4;
  252. InvokeHelper(0x12, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  253.  nNewValue);
  254. }
  255. LPDISPATCH CRdc::GetFont()
  256. {
  257. LPDISPATCH result;
  258. InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  259. return result;
  260. }
  261. void CRdc::SetRefFont(LPDISPATCH newValue)
  262. {
  263. static BYTE parms[] =
  264. VTS_DISPATCH;
  265. InvokeHelper(DISPID_FONT, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  266.  newValue);
  267. }
  268. LPDISPATCH CRdc::GetConnection()
  269. {
  270. LPDISPATCH result;
  271. InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  272. return result;
  273. }
  274. void CRdc::SetRefConnection(LPDISPATCH newValue)
  275. {
  276. static BYTE parms[] =
  277. VTS_DISPATCH;
  278. InvokeHelper(0x13, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  279.  newValue);
  280. }
  281. long CRdc::GetEOFAction()
  282. {
  283. long result;
  284. InvokeHelper(0x14, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  285. return result;
  286. }
  287. void CRdc::SetEOFAction(long nNewValue)
  288. {
  289. static BYTE parms[] =
  290. VTS_I4;
  291. InvokeHelper(0x14, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  292.  nNewValue);
  293. }
  294. long CRdc::GetBOFAction()
  295. {
  296. long result;
  297. InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  298. return result;
  299. }
  300. void CRdc::SetBOFAction(long nNewValue)
  301. {
  302. static BYTE parms[] =
  303. VTS_I4;
  304. InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  305.  nNewValue);
  306. }
  307. long CRdc::GetErrorThreshold()
  308. {
  309. long result;
  310. InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  311. return result;
  312. }
  313. void CRdc::SetErrorThreshold(long nNewValue)
  314. {
  315. static BYTE parms[] =
  316. VTS_I4;
  317. InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  318.  nNewValue);
  319. }
  320. long CRdc::GetLockType()
  321. {
  322. long result;
  323. InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  324. return result;
  325. }
  326. void CRdc::SetLockType(long nNewValue)
  327. {
  328. static BYTE parms[] =
  329. VTS_I4;
  330. InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  331.  nNewValue);
  332. }
  333. long CRdc::GetPrompt()
  334. {
  335. long result;
  336. InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  337. return result;
  338. }
  339. void CRdc::SetPrompt(long nNewValue)
  340. {
  341. static BYTE parms[] =
  342. VTS_I4;
  343. InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  344.  nNewValue);
  345. }
  346. long CRdc::GetAppearance()
  347. {
  348. long result;
  349. InvokeHelper(DISPID_APPEARANCE, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  350. return result;
  351. }
  352. void CRdc::SetAppearance(long nNewValue)
  353. {
  354. static BYTE parms[] =
  355. VTS_I4;
  356. InvokeHelper(DISPID_APPEARANCE, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  357.  nNewValue);
  358. }
  359. LPDISPATCH CRdc::GetEnvironment()
  360. {
  361. LPDISPATCH result;
  362. InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
  363. return result;
  364. }
  365. void CRdc::SetRefEnvironment(LPDISPATCH newValue)
  366. {
  367. static BYTE parms[] =
  368. VTS_DISPATCH;
  369. InvokeHelper(0x1b, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
  370.  newValue);
  371. }
  372. CString CRdc::GetCaption()
  373. {
  374. CString result;
  375. InvokeHelper(DISPID_CAPTION, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
  376. return result;
  377. }
  378. void CRdc::SetCaption(LPCTSTR lpszNewValue)
  379. {
  380. static BYTE parms[] =
  381. VTS_BSTR;
  382. InvokeHelper(DISPID_CAPTION, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  383.  lpszNewValue);
  384. }
  385. unsigned long CRdc::GetBackColor()
  386. {
  387. unsigned long result;
  388. InvokeHelper(DISPID_BACKCOLOR, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  389. return result;
  390. }
  391. void CRdc::SetBackColor(unsigned long newValue)
  392. {
  393. static BYTE parms[] =
  394. VTS_I4;
  395. InvokeHelper(DISPID_BACKCOLOR, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  396.  newValue);
  397. }
  398. unsigned long CRdc::GetForeColor()
  399. {
  400. unsigned long result;
  401. InvokeHelper(DISPID_FORECOLOR, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  402. return result;
  403. }
  404. void CRdc::SetForeColor(unsigned long newValue)
  405. {
  406. static BYTE parms[] =
  407. VTS_I4;
  408. InvokeHelper(DISPID_FORECOLOR, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  409.  newValue);
  410. }
  411. long CRdc::GetBatchCollisionCount()
  412. {
  413. long result;
  414. InvokeHelper(0x1d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  415. return result;
  416. }
  417. VARIANT CRdc::GetBatchCollisionRows()
  418. {
  419. VARIANT result;
  420. InvokeHelper(0x1e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
  421. return result;
  422. }
  423. long CRdc::GetBatchSize()
  424. {
  425. long result;
  426. InvokeHelper(0x1f, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
  427. return result;
  428. }
  429. void CRdc::SetBatchSize(long nNewValue)
  430. {
  431. static BYTE parms[] =
  432. VTS_I4;
  433. InvokeHelper(0x1f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  434.  nNewValue);
  435. }
  436. short CRdc::GetUpdateOperation()
  437. {
  438. short result;
  439. InvokeHelper(0x20, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  440. return result;
  441. }
  442. void CRdc::SetUpdateOperation(short nNewValue)
  443. {
  444. static BYTE parms[] =
  445. VTS_I2;
  446. InvokeHelper(0x20, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  447.  nNewValue);
  448. }
  449. short CRdc::GetUpdateCriteria()
  450. {
  451. short result;
  452. InvokeHelper(0x21, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
  453. return result;
  454. }
  455. void CRdc::SetUpdateCriteria(short nNewValue)
  456. {
  457. static BYTE parms[] =
  458. VTS_I2;
  459. InvokeHelper(0x21, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
  460.  nNewValue);
  461. }
  462. void CRdc::UpdateControls()
  463. {
  464. InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  465. }
  466. void CRdc::UpdateRow()
  467. {
  468. InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  469. }
  470. void CRdc::BeginTrans()
  471. {
  472. InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  473. }
  474. void CRdc::CommitTrans()
  475. {
  476. InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  477. }
  478. void CRdc::RollbackTrans()
  479. {
  480. InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  481. }
  482. void CRdc::Cancel()
  483. {
  484. InvokeHelper(0x28, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  485. }
  486. void CRdc::Refresh()
  487. {
  488. InvokeHelper(DISPID_REFRESH, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  489. }