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