开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
GuiADODB.cpp
资源名称：sourcecode.zip　[点击查看]
上传用户：wlkj888
上传日期：2022-08-01
资源大小：806k
文件大小：27k
源码类别：

对话框与窗口

开发平台：

Visual C++

GuiADODB.cpp：源码内容
  1. /****************************************************************************
  2.  * *  
  3.  * GuiToolKit   *
  4.  *  (MFC extension) *  
  5.  * Created by Francisco Campos G. www.beyondata.com fcampos@beyondata.com *
  6.  *--------------------------------------------------------------------------*    
  7.  * *
  8.  * This program is free software;so you are free to use it any of your *
  9.  * applications (Freeware, Shareware, Commercial),but leave this header *
  10.  * intact. *
  11.  * *
  12.  * These files are provided "as is" without warranty of any kind. *
  13.  * *
  14.  *        GuiToolKit is forever FREE CODE !!!!! *
  15.  * *
  16.  *--------------------------------------------------------------------------*
  17.  * Created by: Francisco Campos G. *
  18.  * Bug Fixes and improvements : (Add your name) *
  19.  * -Francisco Campos *
  20.  * *
  21.  ****************************************************************************/
  25. #include "stdafx.h"
  26. #include "guiadodb.h"
  28. //---------------------------------------------------------------------------------------
  30. CString GetError(_com_error &e)
  31. {
  32. CString MsgBug;
  33. _bstr_t Source(e.Source());
  34. _bstr_t Description(e.Description());
  35. MsgBug.Format( "Ups!!! nSource = %snDescription= %sn",(LPCSTR)Source, (LPCSTR)Description );
  36. #ifdef _DEBUG
  37. AfxMessageBox( MsgBug, MB_OK | MB_ICONERROR );
  38. #endif
  39. return MsgBug;
  40. }
  43. CString GetTypeVar(_variant_t vt)
  44. {
  45. switch(vt.vt)
  46. {
  47. case VT_EMPTY :
  48. return _T("VT_EMPTY");
  49. break;
  50. case   VT_NULL :
  51. return _T("VT_NULL");
  52. break;
  53. case VT_I2:
  54. return _T("int");
  55. break;
  56. case VT_I4 :
  57. return _T("long");
  58. break;
  59. case  VT_R4 :
  60. return _T("float");
  61. break;
  62. case VT_R8 :
  63. return _T("double");
  64. break;
  65. case VT_CY :
  66. return _T("currency");
  67. break;
  68. case VT_DATE:
  69. return _T("date");
  70. break;
  71. case  VT_BSTR :
  72. return _T("string");
  73. break;
  74. case VT_DISPATCH :
  75. return _T("dispatch");
  76. break;
  77. case  VT_ERROR :
  78. return _T("error");
  79. break;
  80. case VT_BOOL :
  81. return _T("bool");
  82. break;
  83. case VT_VARIANT :
  84. return _T("variant");
  85. break;
  86. case VT_UNKNOWN :
  87. return _T("unknown");
  88. break;
  89. case   VT_DECIMAL :
  90. return _T("decimal");
  91. break;
  92. default:
  93. return _T("");
  94. }
  95. }
  97. CGuiConnection::CGuiConnection(void)
  98. {
  99. ::CoInitialize(NULL);
  100. m_pConn.CreateInstance(__uuidof(Connection));
  102. }
  103. CGuiConnection::~CGuiConnection(void)
  104. {
  105. if (IsConnect())
  106. Close();
  107. m_pConn.Release();
  108. m_pConn = NULL;
  110. }
  112. BOOL CGuiConnection::Open(LPCTSTR ConnectionString,LPCTSTR UID,LPCTSTR PWD,long Options)
  113. {
  114.  HRESULT re;
  115.  try
  116. {
  117. re = m_pConn->Open(_bstr_t(ConnectionString), _bstr_t(UID), _bstr_t(PWD), NULL);
  118. return re == S_OK;
  119. }
  120. catch(_com_error &e)
  121. {
  122. GetError(e);
  123. return FALSE;
  124. }
  125.  
  126. }
  128. BOOL CGuiConnection::IsConnect()
  129. {
  130. return (BOOL) m_pConn->GetState() != adStateClosed;
  131. }
  135. CGuiRecordSet* CGuiConnection::Execute(LPCTSTR CommandText,long Options)
  136. {
  137. CGuiRecordSet* m_rs= new CGuiRecordSet();
  138. try{
  139. m_rs->Open(m_pConn,CommandText,adOpenUnspecified,adLockUnspecified, Options);
  140. }catch(_com_error &e)
  141. {
  142. GetError(e);
  143. return NULL;
  144. }
  145. return m_rs;
  146. }
  148. long CGuiConnection::BeginTrans()
  149. {
  150. return m_pConn->BeginTrans();
  151. }
  153. void CGuiConnection::RollbackTrans()
  154. {
  155. m_pConn->RollbackTrans();
  156. }
  158. void CGuiConnection::CommitTrans()
  159. {
  160. m_pConn->CommitTrans();
  161. }
  163. void CGuiConnection::Cancel()
  164. {
  165. m_pConn->Cancel();
  166. }
  168. void CGuiConnection::Close()
  169. {
  170. m_pConn->Close();
  171. }
  173. void CGuiConnection::SetConnectionTimeout(long ConnectionTimeout)
  174. {
  175. m_pConn->ConnectionTimeout=ConnectionTimeout;
  176. }
  178. void CGuiConnection::SetConectionString( LPCTSTR ConnectionString)
  179. {
  180. m_pConn->ConnectionString=ConnectionString;
  181. }
  183. long CGuiConnection::GetConnectionTimeout()
  184. {
  185. return m_pConn->ConnectionTimeout;
  186. }
  188. LPCTSTR CGuiConnection::GetConectionString()
  189. {
  190. return m_pConn->ConnectionString;
  191. }
  194. //***********************************************************************************************
  195. CGuiRecordSet::CGuiRecordSet(void)
  196. {
  197. ::CoInitialize(NULL);
  198. m_rs.CreateInstance(__uuidof(Recordset));
  199. m_Criteria=_T("");
  200. }
  201. CGuiRecordSet::~CGuiRecordSet(void)
  202. {
  203. Close();
  204. if (m_rs) m_rs->Release();
  205. m_rs=NULL;
  206. }
  207. void CGuiRecordSet::Attach(_RecordsetPtr m_prs ) { m_rs=m_prs; } BOOL CGuiRecordSet::Open(_ConnectionPtr ActiveConnection,LPCTSTR Source, CursorTypeEnum CursorType,ADOCG::LockTypeEnum LockType, long Options) { try
  208. {
  209. m_rs->Open(Source, _variant_t((IDispatch*)ActiveConnection, TRUE), 
  210. adOpenStatic, LockType, Options);
  211. }
  212. catch(_com_error &e)
  213. {
  214. GetError(e);
  215. return FALSE;
  216. }
  217. return TRUE; }
  220. BOOL CGuiRecordSet::FindFirst(LPCTSTR Criteria)
  221. {
  222. MoveFirst();
  223.     return Find(Criteria,0,adSearchForward,"");
  224. }
  226. void CGuiRecordSet::Move(long NumRecords , _variant_t Start) { m_rs->Move(NumRecords,vtMissing); }
  227. BOOL CGuiRecordSet::FindNext()
  228. {
  229. return Find(m_Criteria,1,adSearchForward,vtPointer);
  230. }
  233. BOOL CGuiRecordSet::Find(LPCTSTR Criteria , long SkipRecords ,   SearchDirectionEnum SearchDirection,_variant_t Start) { CString szCri=Criteria; if (!szCri.IsEmpty()) m_Criteria=Criteria; else return FALSE; try{ m_rs->Find(_bstr_t(Criteria),SkipRecords,SearchDirection,Start); if (SearchDirection ==adSearchForward) { if (!IsEof()) { vtPointer= m_rs->Bookmark; return TRUE; } }else if (SearchDirection ==adSearchBackward) { if (!IsBof()) { vtPointer= m_rs->Bookmark; return TRUE; } }else return FALSE; }catch(_com_error &e)
  234. {
  235. GetError(e);
  236. return FALSE;
  237. } return FALSE; }
  239. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,CString szCad)
  240. {
  241. _variant_t vt;
  242. if(!szCad.IsEmpty())
  243. {
  244. vt.vt = VT_BSTR;
  245. vt.bstrVal = szCad.AllocSysString();
  246. }
  248. return SetFieldValue(lpName, vt);
  249. }
  251. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,long lVal)
  252. {
  253. _variant_t vt;
  254. vt.lVal=lVal;
  255. vt.vt=VT_I4;
  256. return SetFieldValue(lpName, vt);
  257. }
  259. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned char usVal)
  260. {
  261. _variant_t vt;
  262. vt.bVal=usVal;
  263. vt.vt=VT_UI1;
  264. return SetFieldValue(lpName, vt);
  265. }
  267. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,short shVal)
  268. {
  269. _variant_t vt;
  270. vt.iVal=shVal;
  271. vt.vt=VT_I2;
  272. return SetFieldValue(lpName, vt);
  273. }
  275. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,float flVal)
  276. {
  277. _variant_t vt;
  278. vt.fltVal=flVal;
  279. vt.vt=VT_R4;
  280. return SetFieldValue(lpName, vt);
  281. }
  283. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,double dblVal)
  284. {
  285. _variant_t vt;
  286. vt.dblVal=dblVal;
  287. vt.vt=VT_R8;
  288. return SetFieldValue(lpName, vt);
  289. }
  291. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,BOOL blVal)
  292. {
  293. _variant_t vt;
  294. vt.boolVal=blVal;
  295. vt.vt=VT_BOOL;
  296. return SetFieldValue(lpName, vt);
  297. }
  299. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,COleDateTime dtVal)
  300. {
  301. _variant_t vt;
  302. vt.date=dtVal;
  303. vt.vt=VT_DATE;
  304. return SetFieldValue(lpName, vt);
  305. }
  307. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned long ulVal)
  308. {
  309. _variant_t vt;
  310. vt.vt = VT_UI4;
  311. vt.ulVal = ulVal;
  312. return SetFieldValue(lpName, vt);
  313. }
  315. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName, COleCurrency cuVal)
  316. {
  317. _variant_t vt;
  318. vt.vt = VT_CY;
  319. vt.cyVal = cuVal.m_cur;
  320. if(cuVal.m_status == COleCurrency::invalid)
  321. return FALSE;
  322. return SetFieldValue(lpName, vt);
  323. }
  325. BOOL CGuiRecordSet::SetFieldValue(LPCTSTR lpName, _variant_t vtField)
  326. {
  327. try
  328. {
  329. m_rs->Fields->GetItem(lpName)->Value = vtField; 
  330. return TRUE;
  331. }
  332. catch(_com_error &e)
  333. {
  334. GetError(e);
  335. return FALSE;
  336. }
  337. }
  340. CString CGuiRecordSet::GetCollect(LPCTSTR lpField)
  341. {
  342. try{
  343. _variant_t vt = m_rs->Fields->GetItem(lpField)->Value;
  344.  return (CString) vt.bstrVal;
  345. }
  346. catch(_com_error &e)
  347. {
  348. GetError(e);
  349. return _T("");
  350. }
  351.  
  352. }
  354. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,int& nValue)
  355. {
  356. _variant_t vt;
  357. try
  358. {
  359. vt = m_rs->Fields->GetItem(lpField)->Value;
  360. if (vt.vt==VT_I2)
  361. {
  362. nValue=vt.intVal;
  363. return TRUE;
  364. }else if (vt.vt==VT_BOOL)
  365. {
  366. nValue=vt.boolVal;
  367. return TRUE;
  368. }else return FALSE;
  369. }catch(_com_error &e)
  370. {
  371. GetError(e);
  372. return FALSE;
  373. }
  374. }
  375. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,long& lVal)
  376. {
  377. _variant_t vt;
  378. try
  379. {
  380. vt = m_rs->Fields->GetItem(lpField)->Value;
  381. if (vt.vt==VT_I4)
  382. {
  383. lVal=vt.lVal;
  384. return TRUE;
  385. }else return FALSE;
  386. }catch(_com_error &e)
  387. {
  388. GetError(e);
  389. return FALSE;
  390. }
  392. }
  393. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,double& dbVal)
  394. {
  395. _variant_t vt;
  396. try
  397. {
  398. vt = m_rs->Fields->GetItem(lpField)->Value;
  399. if (vt.vt==VT_R8)
  400. {
  401. dbVal=vt.dblVal;
  402. return TRUE;
  403. }else return FALSE;
  404. }catch(_com_error &e)
  405. {
  406. GetError(e);
  407. return FALSE;
  408. }
  409. }
  410. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,CString& strValue)
  411. {
  412. _variant_t vt;
  413. try
  414. {
  415. vt = m_rs->Fields->GetItem(lpField)->Value;
  416. if (vt.vt==VT_BSTR)
  417. {
  418. strValue=vt.bstrVal;
  419. return TRUE;
  420. }else return FALSE;
  421. }catch(_com_error &e)
  422. {
  423. GetError(e);
  424. return FALSE;
  425. }
  426. }
  429. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleCurrency& cyVal)
  430. {
  431. _variant_t vt;
  432. vt = m_rs->Fields->GetItem(lpField)->Value;
  434. try
  435. {
  436. if (vt.vt==VT_CY)
  437. {
  438. cyVal.m_cur=vt.cyVal;
  439. return TRUE;
  440. }else return FALSE;
  441. }catch(_com_error &e)
  442. {
  443. GetError(e);
  444. return FALSE;
  445. }
  447. }
  449. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleDateTime& dtVal)
  450. {
  451. _variant_t vt;
  452. try
  453. {
  454. vt = m_rs->Fields->GetItem(lpField)->Value;
  455. if (vt.vt==VT_DATE)
  456. {
  457. dtVal=vt.date;
  458. return TRUE;
  459. }else return FALSE;
  460. }catch(_com_error &e)
  461. {
  462. GetError(e);
  463. return FALSE;
  464. }
  465. }
  466. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,float& flVal)
  467. {
  468. _variant_t vt;
  469. try
  470. {
  471. vt = m_rs->Fields->GetItem(lpField)->Value;
  472. if (vt.vt==VT_R4)
  473. {
  474. flVal=vt.fltVal;
  475. return TRUE;
  476. }else return FALSE;
  477. }catch(_com_error &e)
  478. {
  479. GetError(e);
  480. return FALSE;
  481. }
  482. }
  484. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,_variant_t& vt)
  485. {
  486. try
  487. {
  488. vt = m_rs->Fields->GetItem(lpField)->Value;
  489. return TRUE;
  490. }
  491. catch(_com_error& e)
  492. {
  493. GetError(e);
  494. return FALSE;
  495. }
  496. }
  498. BOOL CGuiRecordSet::GetCollect(int nIndex,int& nValue)
  499. {
  500. _variant_t vt;
  501. _variant_t vtn;
  502. vtn.vt = VT_I2;
  503. try
  504. {
  505. vtn.iVal = nIndex;
  506. vt = m_rs->Fields->GetItem(vtn)->Value;
  507. if (vt.vt==VT_I2)
  508. {
  509. nValue=vt.intVal;
  510. return TRUE;
  511. }else return FALSE;
  512. }catch(_com_error &e)
  513. {
  514. GetError(e);
  515. return FALSE;
  516. }
  518. }
  520. BOOL CGuiRecordSet::GetCollect(int nIndex,long& lVal)
  521. {
  522. _variant_t vt;
  523. _variant_t vtn;
  524. vtn.vt = VT_I2;
  525. try
  526. {
  527. vtn.iVal = nIndex;
  528. vt = m_rs->Fields->GetItem(vtn)->Value;
  529. if (vt.vt==VT_I4)
  530. {
  531. lVal=vt.lVal;
  532. return TRUE;
  533. }else return FALSE;
  534. }catch(_com_error &e)
  535. {
  536. GetError(e);
  537. return FALSE;
  538. }
  540. }
  542. BOOL CGuiRecordSet::GetCollect(int nIndex,double& dbVal)
  543. {
  544. _variant_t vt;
  545. _variant_t vtn;
  546. vtn.vt = VT_I2;
  547. try
  548. {
  549. vtn.iVal = nIndex;
  550. vt = m_rs->Fields->GetItem(vtn)->Value;
  551. if (vt.vt==VT_R8)
  552. {
  553. dbVal=vt.dblVal;
  554. return TRUE;
  555. }else return FALSE;
  556. }catch(_com_error &e)
  557. {
  558. GetError(e);
  559. return FALSE;
  560. }
  561. }
  563. BOOL CGuiRecordSet::GetCollect(int nIndex,CString& strValue)
  564. {
  565. _variant_t vt;
  566. _variant_t vtn;
  567. vtn.vt = VT_I2;
  568. try
  569. {
  570. vtn.iVal = nIndex;
  571. vt = m_rs->Fields->GetItem(vtn)->Value;
  572. if (vt.vt==VT_BSTR)
  573. {
  574. strValue=vt.bstrVal;
  575. return TRUE;
  576. }else return FALSE;
  577. }catch(_com_error &e)
  578. {
  579. GetError(e);
  580. return FALSE;
  581. }
  582. }
  584. BOOL CGuiRecordSet::GetCollect(int nIndex,COleCurrency& cyVal)
  585. {
  586. _variant_t vt;
  587. _variant_t vtn;
  588. vtn.vt = VT_CY;
  589. try
  590. {
  591. vtn.iVal =nIndex;
  592. vt = m_rs->Fields->GetItem(vtn)->Value;
  593. if (vt.vt==VT_CY)
  594. {
  595. cyVal.m_cur=vt.cyVal;
  596. return TRUE;
  597. }else return FALSE;
  598. }catch(_com_error &e)
  599. {
  600. GetError(e);
  601. return FALSE;
  602. }
  604. }
  606. BOOL CGuiRecordSet::GetCollect(int nIndex,COleDateTime& dtVal)
  607. {
  608. _variant_t vt;
  609. _variant_t vtn;
  610. vtn.vt = VT_I2;
  611. try
  612. {
  613. vtn.iVal = nIndex;
  614. vt = m_rs->Fields->GetItem(vtn)->Value;
  615. if (vt.vt==VT_DATE)
  616. {
  617. dtVal=vt.date;
  618. return TRUE;
  619. }else return FALSE;
  620. }catch(_com_error &e)
  621. {
  622. GetError(e);
  623. return FALSE;
  624. }
  626. }
  628. BOOL CGuiRecordSet::GetFormatDate(LPCTSTR lpField,CString& m_szDate, CString Format)
  629. {
  630. COleDateTime time;
  631. if (!GetCollect(lpField,time)) return FALSE;
  632. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  633. m_szDate =ct.Format(Format);
  634. return TRUE;
  635. }
  637. BOOL CGuiRecordSet::GetFormatDate(int nIndex,CString& m_szDate, CString Format)
  638. {
  639. COleDateTime time;
  640. if (!GetCollect(nIndex,time)) return FALSE;
  641. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  642. m_szDate =ct.Format(Format);
  643. return TRUE;
  644. }
  646. BOOL CGuiRecordSet::GetCollect(int nIndex,float& flVal)
  647. {
  648. _variant_t vt;
  649. _variant_t vtn;
  650. vtn.vt = VT_I2;
  651. try
  652. {
  653. vtn.iVal = nIndex;
  654. vt = m_rs->Fields->GetItem(vtn)->Value;
  655. if (vt.vt==VT_R4)
  656. {
  657. flVal=vt.fltVal;
  658. return TRUE;
  659. }else return FALSE;
  660. }catch(_com_error &e)
  661. {
  662. GetError(e);
  663. return FALSE;
  664. }
  666. }
  670. BOOL CGuiRecordSet::GetCollect(int nIndex,_variant_t& vt)
  671. {
  673. _variant_t vtn;
  674. vtn.vt = VT_I2;
  675. try
  676. {
  677. vtn.iVal = nIndex;
  678. vt = m_rs->Fields->GetItem(vtn)->Value;
  679. return TRUE;
  680. }
  681. catch(_com_error& e)
  682. {
  683. GetError(e);
  684. return FALSE;
  685. }
  686. }
  691. BOOL CGuiRecordSet::SetFilter(LPCTSTR lpFilter)
  692. {
  693. if (!IsOpen()) return FALSE;
  694. try
  695. {
  696. m_rs->PutFilter(lpFilter);
  697. return TRUE;
  698. }
  699. catch(_com_error &e)
  700. {
  701. GetError(e);
  702. return FALSE;
  703. }
  704. }
  706. BOOL CGuiRecordSet::SetSort(LPCTSTR lpSort)
  707. {
  708. if (!IsOpen()) return FALSE;
  709. try
  710. {
  711. m_rs->PutSort(lpSort);
  712. return TRUE;
  713. }
  714. catch(_com_error &e)
  715. {
  716. GetError(e);
  717. return FALSE;
  718. }
  719. }
  722. BOOL CGuiRecordSet::IsOpen()
  723. {
  724. if(m_rs)
  725. return m_rs-> GetState() != adStateClosed;
  726. return FALSE;
  727. }
  729. void CGuiRecordSet::Close()
  730. {
  731. if(IsOpen())
  732. m_rs->Close();
  734. }
  737. void CGuiRecordSet::MoveFirst()
  738. {
  739. m_rs->MoveFirst();
  740. }
  742. void CGuiRecordSet::MoveLast()
  743. {
  744. m_rs->MoveLast();
  745. }
  747. void CGuiRecordSet::MoveNext()
  748. {
  749. m_rs->MoveNext();
  750. }
  752. void CGuiRecordSet::MovePrevious()
  753. {
  754. m_rs->MovePrevious();
  755. }
  757. void CGuiRecordSet::Cancel()
  758. {
  759.    m_rs->Cancel();
  760. }
  762. void CGuiRecordSet::CancelUpdate()
  763. {
  764.   m_rs->CancelUpdate();
  765. }
  767. BOOL CGuiRecordSet::Delete()
  768. {
  769. try{
  770. if(m_rs->Delete(adAffectCurrent)== S_OK)
  771. if(m_rs->Update() ==S_OK)
  772. return TRUE;
  773. }catch(_com_error &e)
  774. {
  775. GetError(e);
  776. return FALSE;
  777. }
  778. return FALSE;
  779. }
  781. BOOL CGuiRecordSet::IsEof()
  782. {
  783. return (BOOL)m_rs->EndOfFile;
  784. }
  785. BOOL CGuiRecordSet::IsBof()
  786. {
  787. return (BOOL)m_rs->BOF;
  788. }
  789. BOOL CGuiRecordSet::Supports( CursorOptionEnum CursorOptions )  {   return (BOOL)m_rs->Supports(CursorOptions); }
  790. void CGuiRecordSet::CancelBatch(AffectEnum AffectRecords) {   m_rs->CancelBatch(AffectRecords); } CGuiField CGuiRecordSet::GetField(LPCTSTR lpField)
  791. {
  792. FieldPtr pField = m_rs->Fields->GetItem(lpField);
  793. CGuiField Field;
  794. Field.Attach(pField);
  795. return Field;
  796. }
  797. CGuiField CGuiRecordSet::GetField(int Index) { _variant_t vtIndex;
  798. vtIndex.vt = VT_I2;
  799. vtIndex.iVal = Index;
  800. FieldPtr pField = m_rs->Fields->GetItem(vtIndex); CGuiField Field;
  801. Field.Attach(pField);
  802. return Field; } CGuiRecordSet*  CGuiRecordSet::Clone(ADOCG::LockTypeEnum LockType) { _RecordsetPtr m_rs1=m_rs->Clone(LockType); CGuiRecordSet* m_pRs= new CGuiRecordSet(); m_pRs->Attach(m_rs1); return m_pRs;  } CGuiRecordSet* CGuiRecordSet::NextRecordset(long RecordsAffected)  { _RecordsetPtr m_rs1=m_rs->NextRecordset((VARIANT*)RecordsAffected); CGuiRecordSet* m_pRs= new CGuiRecordSet(); m_pRs->Attach(m_rs1); return m_pRs;  }
  803. //***********************************************************************************************************
  804. CGuiField::CGuiField(void)
  805. {
  806. }
  807. CGuiField::~CGuiField(void)
  808. {
  809. }
  810. BOOL CGuiField::SetValue(long lVal)
  811. {
  812. _variant_t vt;
  813. vt.lVal=lVal;
  814. vt.vt=VT_I4;
  815. try
  816. {
  817. field->Value=vt;
  818. return TRUE;
  819. }catch(_com_error &e)
  820. {
  821. GetError(e);
  822. return FALSE;
  823. }
  825. }
  829. BOOL CGuiField::SetValue(float flVal)
  830. {
  831. _variant_t vt;
  832. vt.fltVal=flVal;
  833. vt.vt=VT_R4;
  834. try
  835. {
  836. field->Value=vt;
  837. return TRUE;
  838. }catch(_com_error &e)
  839. {
  840. GetError(e);
  841. return FALSE;
  842. }
  843. }
  846. BOOL CGuiField::SetValue(int nVal)
  847. {
  848. _variant_t vt;
  849. vt.intVal=nVal;
  850. vt.vt=VT_I2;
  851. try
  852. {
  853. field->Value=vt;
  854. return TRUE;
  855. }catch(_com_error &e)
  856. {
  857. GetError(e);
  858. return FALSE;
  859. }
  862. }
  864. BOOL CGuiField::SetValue(double dbVal)
  865. {
  866. _variant_t vt;
  867. vt.dblVal=dbVal;
  868. vt.vt=VT_R8;
  870. try
  871. {
  872. field->Value=vt;
  873. return TRUE;
  874. }catch(_com_error &e)
  875. {
  876. GetError(e);
  877. return FALSE;
  878. }
  880. }
  882. BOOL CGuiField::SetValue(CString szCad)
  883. {
  884. _variant_t vt;
  885. if(!szCad.IsEmpty())
  886. {
  887. vt.vt = VT_BSTR;
  888. vt.bstrVal = szCad.AllocSysString();
  889. }
  890. try
  891. {
  892. field->Value=vt;
  893. return TRUE;
  894. }catch(_com_error &e)
  895. {
  896. GetError(e);
  897. return FALSE;
  898. }
  901. }
  904. BOOL CGuiField::SetValue(bool blVal)
  905. {
  906. _variant_t vt;
  907. vt.boolVal=blVal;
  908. vt.vt=VT_BOOL;
  909. try
  910. {
  911. field->Value=vt;
  912. return TRUE;
  913. }catch(_com_error &e)
  914. {
  915. GetError(e);
  916. return FALSE;
  917. }
  918. }
  921. BOOL CGuiField::SetValue(COleDateTime dtVal)
  922. {
  923. _variant_t vt;
  924. vt.date=dtVal;
  925. vt.vt=VT_DATE;
  926. try
  927. {
  928. field->Value=vt;
  929. return TRUE;
  930. }catch(_com_error &e)
  931. {
  932. GetError(e);
  933. return FALSE;
  934. }
  936. }
  938. BOOL CGuiField::SetValue(_variant_t vt)
  939. {
  940. try
  941. {
  942. field->Value=vt;
  943. return TRUE;
  944. }catch(_com_error &e)
  945. {
  946. GetError(e);
  947. return FALSE;
  948. }
  950. }
  952. BOOL CGuiField::GetValue(int& nVal)
  953. {
  954. _variant_t vt;
  955. vt = field->Value;
  956. try
  957. {
  958. if (vt.vt==VT_I2)
  959. {
  960. nVal=vt.intVal;
  961. return TRUE;
  962. }else if (vt.vt==VT_BOOL)
  963. {
  964. nVal=vt.boolVal;
  965. return TRUE;
  966. }else return FALSE;
  967. }catch(_com_error &e)
  968. {
  969. GetError(e);
  970. return FALSE;
  971. }
  973. }
  975. BOOL CGuiField::GetValue(long& lVal)
  976. {
  977. _variant_t vt;
  978. vt = field->Value;
  979. try
  980. {
  981. if (vt.vt==VT_I4)
  982. {
  983. lVal=vt.lVal;
  984. return TRUE;
  985. }else return FALSE;
  986. }catch(_com_error &e)
  987. {
  988. GetError(e);
  989. return FALSE;
  990. }
  992. }
  994. BOOL CGuiField::GetValue(double& dbVal)
  995. {
  996. _variant_t vt;
  997. vt = field->Value;
  998. try
  999. {
  1000. if (vt.vt==VT_R8)
  1001. {
  1002. dbVal=vt.dblVal;
  1003. return TRUE;
  1004. }else return FALSE;
  1005. }catch(_com_error &e)
  1006. {
  1007. GetError(e);
  1008. return FALSE;
  1009. }
  1010. }
  1012. BOOL CGuiField::GetValue(CString& strValue)
  1013. {
  1014. _variant_t vt;
  1015. vt =field->Value;
  1017. try
  1018. {
  1019. if (vt.vt==VT_BSTR)
  1020. {
  1021. strValue=vt.bstrVal;
  1022. return TRUE;
  1023. }else return FALSE;
  1024. }catch(_com_error &e)
  1025. {
  1026. GetError(e);
  1027. return FALSE;
  1028. }
  1029. }
  1031. BOOL CGuiField::GetValue(COleDateTime& dtVal)
  1032. {
  1033. _variant_t vt;
  1034. vt = field->Value;
  1035. try
  1036. {
  1037. if (vt.vt==VT_DATE)
  1038. {
  1039. dtVal=vt.date;
  1040. return TRUE;
  1041. }else return FALSE;
  1042. }catch(_com_error &e)
  1043. {
  1044. GetError(e);
  1045. return FALSE;
  1046. }
  1048. }
  1050. BOOL CGuiField::GetValue(float& flVal)
  1051. {
  1052. _variant_t vt;
  1053. vt = field->Value;
  1054. try
  1055. {
  1056. if (vt.vt==VT_R4)
  1057. {
  1058. flVal=vt.fltVal;
  1059. return TRUE;
  1060. }else return FALSE;
  1061. }catch(_com_error &e)
  1062. {
  1063. GetError(e);
  1064. return FALSE;
  1065. }
  1067. }
  1071. BOOL CGuiField::GetValue(_variant_t& vt)
  1072. {
  1073. try
  1074. {
  1075. _variant_t vt = field->Value;
  1076. return TRUE;
  1077. }
  1078. catch(_com_error& e)
  1079. {
  1080. GetError(e);
  1081. return FALSE;
  1082. }
  1083. }
  1086. //***********************************************************************************************************
  1088. CGuiParameter::CGuiParameter()
  1089. {
  1090. ::CoInitialize(NULL);
  1091. pParam.CreateInstance(__uuidof(Parameter));
  1092. }
  1094. CGuiParameter::~CGuiParameter()
  1095. {
  1096. pParam->Release();
  1097. pParam=NULL;
  1098. }
  1101. void CGuiParameter::SetAttributes(long Attributes)
  1102. {
  1103. pParam->PutAttributes(Attributes);
  1104. }
  1106. void CGuiParameter::SetDirection(ADOCG::ParameterDirectionEnum Direction)
  1107. {
  1108. pParam->PutDirection(Direction);
  1109. }
  1111. void CGuiParameter::SetName(LPCTSTR szName)
  1112. {
  1113. CString mszname=szName;
  1114. pParam->Name=mszname.AllocSysString();
  1116. }
  1118. void CGuiParameter::SetNumericScale(unsigned char NumericScale)
  1119. {
  1120. pParam->PutNumericScale(NumericScale);
  1121. }
  1123. void CGuiParameter::SetPrecision(unsigned char Precision)
  1124. {
  1125. pParam->PutPrecision(Precision);
  1126. }
  1128. void CGuiParameter::SetSize(long Size)
  1129. {
  1130. pParam->PutSize(Size);
  1131. }
  1133. void CGuiParameter::SetType(ADOCG::DataTypeEnum Type)
  1134. {
  1135. pParam->PutType(Type);
  1136. }
  1138. BOOL CGuiParameter::SetValue(long lVal)
  1139. {
  1140. _variant_t vt;
  1141. vt.lVal=lVal;
  1142. vt.vt=VT_I4;
  1143. try
  1144. {
  1145. pParam->Value=vt;
  1146. return TRUE;
  1147. }catch(_com_error &e)
  1148. {
  1149. GetError(e);
  1150. return FALSE;
  1151. }
  1153. }
  1157. BOOL CGuiParameter::SetValue(float flVal)
  1158. {
  1159. _variant_t vt;
  1160. vt.fltVal=flVal;
  1161. vt.vt=VT_R4;
  1162. try
  1163. {
  1164. pParam->Value=vt;
  1165. return TRUE;
  1166. }catch(_com_error &e)
  1167. {
  1168. GetError(e);
  1169. return FALSE;
  1170. }
  1171. }
  1174. BOOL CGuiParameter::SetValue(int nVal)
  1175. {
  1176. _variant_t vt;
  1177. vt.intVal=nVal;
  1178. vt.vt=VT_I2;
  1179. try
  1180. {
  1181. pParam->Value=vt;
  1182. return TRUE;
  1183. }catch(_com_error &e)
  1184. {
  1185. GetError(e);
  1186. return FALSE;
  1187. }
  1190. }
  1192. BOOL CGuiParameter::SetValue(double dbVal)
  1193. {
  1194. _variant_t vt;
  1195. vt.dblVal=dbVal;
  1196. vt.vt=VT_R8;
  1198. try
  1199. {
  1200. pParam->Value=vt;
  1201. return TRUE;
  1202. }catch(_com_error &e)
  1203. {
  1204. GetError(e);
  1205. return FALSE;
  1206. }
  1208. }
  1210. BOOL CGuiParameter::SetValue(CString szCad)
  1211. {
  1212. _variant_t vt;
  1213. if(!szCad.IsEmpty())
  1214. {
  1215. vt.vt = VT_BSTR;
  1216. vt.bstrVal = szCad.AllocSysString();
  1217. }
  1218. try
  1219. {
  1220. pParam->Value=vt;
  1221. return TRUE;
  1222. }catch(_com_error &e)
  1223. {
  1224. GetError(e);
  1225. return FALSE;
  1226. }
  1229. }
  1232. BOOL CGuiParameter::SetValue(bool blVal)
  1233. {
  1234. _variant_t vt;
  1235. vt.boolVal=blVal;
  1236. vt.vt=VT_BOOL;
  1237. try
  1238. {
  1239. pParam->Value=vt;
  1240. return TRUE;
  1241. }catch(_com_error &e)
  1242. {
  1243. GetError(e);
  1244. return FALSE;
  1245. }
  1246. }
  1249. BOOL CGuiParameter::SetValue(COleDateTime dtVal)
  1250. {
  1251. _variant_t vt;
  1252. vt.date=dtVal;
  1253. vt.vt=VT_DATE;
  1254. try
  1255. {
  1256. pParam->Value=vt;
  1257. return TRUE;
  1258. }catch(_com_error &e)
  1259. {
  1260. GetError(e);
  1261. return FALSE;
  1262. }
  1264. }
  1266. BOOL CGuiParameter::SetValue(_variant_t vt)
  1267. {
  1268. try
  1269. {
  1270. pParam->Value=vt;
  1271. return TRUE;
  1272. }catch(_com_error &e)
  1273. {
  1274. GetError(e);
  1275. return FALSE;
  1276. }
  1278. }
  1280. BOOL CGuiParameter::GetValue(int& nVal)
  1281. {
  1282. _variant_t vt;
  1283. vt = pParam->Value;
  1284. try
  1285. {
  1286. if (vt.vt==VT_I2)
  1287. {
  1288. nVal=vt.intVal;
  1289. return TRUE;
  1290. }else if (vt.vt==VT_BOOL)
  1291. {
  1292. nVal=vt.boolVal;
  1293. return TRUE;
  1294. }else return FALSE;
  1295. }catch(_com_error &e)
  1296. {
  1297. GetError(e);
  1298. return FALSE;
  1299. }
  1301. }
  1303. BOOL CGuiParameter::GetValue(long& lVal)
  1304. {
  1305. _variant_t vt;
  1306. vt = pParam->Value;
  1307. try
  1308. {
  1309. if (vt.vt==VT_I4)
  1310. {
  1311. lVal=vt.lVal;
  1312. return TRUE;
  1313. }if (vt.vt==VT_BSTR)
  1314. {
  1315. CString cad=vt.bstrVal;
  1316. lVal=atol(cad);
  1317. return TRUE;
  1318. }
  1319. else return FALSE;
  1320. }catch(_com_error &e)
  1321. {
  1322. GetError(e);
  1323. return FALSE;
  1324. }
  1326. }
  1328. BOOL CGuiParameter::SetValue(COleCurrency cyVal)
  1329. {
  1330. _variant_t vt;
  1331. vt.cyVal=cyVal.m_cur;
  1332. vt.vt=VT_CY;
  1333. try
  1334. {
  1335. pParam->Value=vt;
  1336. return TRUE;
  1337. }catch(_com_error &e)
  1338. {
  1339. GetError(e);
  1340. return FALSE;
  1341. }
  1343. }
  1345. BOOL CGuiParameter::GetValue(double& dbVal)
  1346. {
  1347. _variant_t vt;
  1348. vt = pParam->Value;
  1349. try
  1350. {
  1351. if (vt.vt==VT_R8)
  1352. {
  1353. dbVal=vt.dblVal;
  1354. return TRUE;
  1355. }else return FALSE;
  1356. }catch(_com_error &e)
  1357. {
  1358. GetError(e);
  1359. return FALSE;
  1360. }
  1361. }
  1363. BOOL CGuiParameter::GetValue(CString& strValue)
  1364. {
  1365. _variant_t vt;
  1366. vt =pParam->Value;
  1368. try
  1369. {
  1370. if (vt.vt==VT_BSTR)
  1371. {
  1372. strValue=vt.bstrVal;
  1373. return TRUE;
  1374. }else return FALSE;
  1375. }catch(_com_error &e)
  1376. {
  1377. GetError(e);
  1378. return FALSE;
  1379. }
  1380. }
  1382. BOOL CGuiParameter::GetValue(COleDateTime& dtVal)
  1383. {
  1384. _variant_t vt;
  1385. vt = pParam->Value;
  1386. try
  1387. {
  1388. if (vt.vt==VT_DATE)
  1389. {
  1390. dtVal=vt.date;
  1391. return TRUE;
  1392. }else return FALSE;
  1393. }catch(_com_error &e)
  1394. {
  1395. GetError(e);
  1396. return FALSE;
  1397. }
  1399. }
  1401. BOOL CGuiParameter::GetValue(COleCurrency& cyVal)
  1402. {
  1403. _variant_t vt;
  1404. vt = pParam->Value;
  1406. try
  1407. {
  1408. if (vt.vt==VT_CY)
  1409. {
  1410. cyVal.m_cur=vt.cyVal;
  1411. return TRUE;
  1412. }else return FALSE;
  1413. }catch(_com_error &e)
  1414. {
  1415. GetError(e);
  1416. return FALSE;
  1417. }
  1419. }
  1422. BOOL CGuiParameter::GetFormatDate(CString& m_szDate, CString Format)
  1423. {
  1424. COleDateTime time;
  1425. if (!GetValue(time)) return FALSE;
  1426. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  1427. m_szDate =ct.Format(Format);
  1428. return TRUE;
  1429. }
  1433. BOOL CGuiParameter::GetValue(float& flVal)
  1434. {
  1435. _variant_t vt;
  1436. vt = pParam->Value;
  1437. try
  1438. {
  1439. if (vt.vt==VT_R4)
  1440. {
  1441. flVal=vt.fltVal;
  1442. return TRUE;
  1443. }else return FALSE;
  1444. }catch(_com_error &e)
  1445. {
  1446. GetError(e);
  1447. return FALSE;
  1448. }
  1450. }
  1454. BOOL CGuiParameter::GetValue(_variant_t& vt)
  1455. {
  1456. try
  1457. {
  1458. _variant_t vt = pParam->Value;
  1459. return TRUE;
  1460. }
  1461. catch(_com_error& e)
  1462. {
  1463. GetError(e);
  1464. return FALSE;
  1465. }
  1466. }
  1469. //----------------------------------------------------------------------------------------------
  1471. CGuiCommand::CGuiCommand()
  1472. {
  1473. ::CoInitialize(NULL);
  1474. pCommand.CreateInstance(__uuidof(Command));
  1476. }
  1478. CGuiCommand::~CGuiCommand()
  1479. {
  1480. Cancel();
  1481. pCommand->Release();
  1482. pCommand=NULL;
  1483. }
  1486. void CGuiCommand::SetActiveConnection(LPCTSTR szconnec)
  1487. {
  1488. m_pCon.Open(szconnec);
  1489. ASSERT( m_pCon.IsConnect());
  1490. SetActiveConnection(&m_pCon);
  1491. }
  1493. void CGuiCommand::SetActiveConnection(CGuiConnection* pCon)
  1494. {
  1495. ASSERT(pCon->IsConnect());
  1496. pCommand->ActiveConnection=pCon->GetConecction();
  1497. }
  1499. void CGuiCommand::Cancel()
  1500. {
  1501. pCommand->Cancel();
  1502. } 
  1504. void CGuiCommand::SetCommandText(LPCTSTR lpCommand,CommandTypeEnum cmdType)
  1505. {
  1506. CString szCommand=lpCommand;
  1507. pCommand->CommandText=szCommand.AllocSysString();
  1508. pCommand->PutCommandType(cmdType);
  1509. }
  1511. void CGuiCommand::SetCommandTimeout(long CommandTimeout)
  1512. {
  1513. pCommand->PutCommandTimeout(CommandTimeout);
  1514. }
  1516. void CGuiCommand::SetPrepared(BOOL prepared)
  1517. {
  1518. pCommand->PutPrepared((BOOL) prepared);
  1519. }
  1521. long CGuiCommand::GetState()
  1522. {
  1523. return pCommand->GetState();
  1524. }
  1526. CGuiRecordSet* CGuiCommand::Execute(VARIANT* param1,VARIANT* param2,long Options)
  1527. {
  1528. try
  1529. {
  1530. _RecordsetPtr m_rs = pCommand->Execute(NULL, NULL, Options);
  1531. CGuiRecordSet* m_prs= new CGuiRecordSet();
  1532. m_prs->Attach(m_rs);
  1533. return m_prs;
  1534. }
  1535. catch(_com_error &e)
  1536. {
  1537. GetError(e);
  1538. return NULL;
  1539. }
  1541. }
  1543. CGuiParameter* CGuiCommand::CreateParameter(CString Name ,long Size ,
  1544. ADOCG::DataTypeEnum Type, 
  1545. ADOCG::ParameterDirectionEnum Direction)
  1546. {
  1547. _ParameterPtr param=pCommand->CreateParameter(Name.AllocSysString(), Type,Direction, Size);
  1549. CGuiParameter* pParam=new CGuiParameter();
  1550. pParam->Attach(param);
  1551. return pParam;
  1552. }
  1554. BOOL CGuiCommand::Append(CGuiParameter* pParam)
  1555. {
  1556. try
  1557. {
  1558. pCommand->Parameters->Append(pParam->GetParameter());
  1559. return TRUE;
  1560. }
  1561. catch(_com_error& e)
  1562. {
  1563. GetError(e);
  1564. return FALSE;
  1565. }
  1567. }