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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 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.  * Chenlu Li (wikilee@263.net) *
  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. Close();
  106. m_pConn.Release();
  107. m_pConn = NULL;
  109. }
  111. BOOL CGuiConnection::Open(LPCTSTR ConnectionString,LPCTSTR UID,LPCTSTR PWD,long Options)
  112. {
  113.  HRESULT re;
  114.  try
  115. {
  116. re = m_pConn->Open(_bstr_t(ConnectionString), _bstr_t(UID), _bstr_t(PWD), Options);
  117. return re == S_OK;
  118. }
  119. catch(_com_error &e)
  120. {
  121. GetError(e);
  122. return FALSE;
  123. }
  124.  
  125. }
  127. BOOL CGuiConnection::IsConnect()
  128. {
  129. return (BOOL) m_pConn->GetState() != adStateClosed;
  130. }
  134. CGuiRecordSet* CGuiConnection::Execute(LPCTSTR CommandText,long Options)
  135. {
  136. CGuiRecordSet* m_rs= new CGuiRecordSet();
  137. try{
  138. m_rs->Open(m_pConn,CommandText,adOpenUnspecified,adLockUnspecified, Options);
  139. }catch(_com_error &e)
  140. {
  141. GetError(e);
  142. return NULL;
  143. }
  144. return m_rs;
  145. }
  147. long CGuiConnection::BeginTrans()
  148. {
  149. return m_pConn->BeginTrans();
  150. }
  152. void CGuiConnection::RollbackTrans()
  153. {
  154. m_pConn->RollbackTrans();
  155. }
  157. void CGuiConnection::CommitTrans()
  158. {
  159. m_pConn->CommitTrans();
  160. }
  162. void CGuiConnection::Cancel()
  163. {
  164. m_pConn->Cancel();
  165. }
  167. void CGuiConnection::Close()
  168. {
  169. if (IsConnect())m_pConn->Close();
  170. }
  172. void CGuiConnection::SetConnectionTimeout(long ConnectionTimeout)
  173. {
  174. m_pConn->ConnectionTimeout=ConnectionTimeout;
  175. }
  177. void CGuiConnection::SetConectionString( LPCTSTR ConnectionString)
  178. {
  179. m_pConn->ConnectionString=ConnectionString;
  180. }
  182. long CGuiConnection::GetConnectionTimeout()
  183. {
  184. return m_pConn->ConnectionTimeout;
  185. }
  187. LPCTSTR CGuiConnection::GetConectionString()
  188. {
  189. return m_pConn->ConnectionString;
  190. }
  193. //***********************************************************************************************
  194. CGuiRecordSet::CGuiRecordSet(void)
  195. {
  196. ::CoInitialize(NULL);
  197. m_rs.CreateInstance(__uuidof(Recordset));
  198. m_Criteria=_T("");
  199. }
  200. CGuiRecordSet::~CGuiRecordSet(void)
  201. {
  202. Close();
  203. if (m_rs) m_rs.Release();
  204. m_rs=NULL;
  205. }
  206. 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
  207. {
  208. m_rs->Open(Source, _variant_t((IDispatch*)ActiveConnection, TRUE), 
  209. adOpenStatic, LockType, Options);
  210. }
  211. catch(_com_error &e)
  212. {
  213. GetError(e);
  214. return FALSE;
  215. }
  216. return TRUE; }
  219. BOOL CGuiRecordSet::FindFirst(LPCTSTR Criteria)
  220. {
  221. MoveFirst();
  222.     return Find(Criteria,0,adSearchForward,"");
  223. }
  225. void CGuiRecordSet::Move(long NumRecords , _variant_t Start) { m_rs->Move(NumRecords,vtMissing); }
  226. BOOL CGuiRecordSet::FindNext()
  227. {
  228. return Find(m_Criteria,1,adSearchForward,vtPointer);
  229. }
  232. 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)
  233. {
  234. GetError(e);
  235. return FALSE;
  236. } return FALSE; }
  238. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,CString szCad)
  239. {
  240. _variant_t vt;
  241. if(!szCad.IsEmpty())
  242. {
  243. vt.vt = VT_BSTR;
  244. vt.bstrVal = szCad.AllocSysString();
  245. }
  247. return SetFieldValue(lpName, vt);
  248. }
  250. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,long lVal)
  251. {
  252. _variant_t vt;
  253. vt.lVal=lVal;
  254. vt.vt=VT_I4;
  255. return SetFieldValue(lpName, vt);
  256. }
  258. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned char usVal)
  259. {
  260. _variant_t vt;
  261. vt.bVal=usVal;
  262. vt.vt=VT_UI1;
  263. return SetFieldValue(lpName, vt);
  264. }
  266. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,short shVal)
  267. {
  268. _variant_t vt;
  269. vt.iVal=shVal;
  270. vt.vt=VT_I2;
  271. return SetFieldValue(lpName, vt);
  272. }
  274. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,float flVal)
  275. {
  276. _variant_t vt;
  277. vt.fltVal=flVal;
  278. vt.vt=VT_R4;
  279. return SetFieldValue(lpName, vt);
  280. }
  282. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,double dblVal)
  283. {
  284. _variant_t vt;
  285. vt.dblVal=dblVal;
  286. vt.vt=VT_R8;
  287. return SetFieldValue(lpName, vt);
  288. }
  290. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,BOOL blVal)
  291. {
  292. _variant_t vt;
  293. vt.boolVal=blVal;
  294. vt.vt=VT_BOOL;
  295. return SetFieldValue(lpName, vt);
  296. }
  298. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,COleDateTime dtVal)
  299. {
  300. _variant_t vt;
  301. vt.date=dtVal;
  302. vt.vt=VT_DATE;
  303. return SetFieldValue(lpName, vt);
  304. }
  306. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName,unsigned long ulVal)
  307. {
  308. _variant_t vt;
  309. vt.vt = VT_UI4;
  310. vt.ulVal = ulVal;
  311. return SetFieldValue(lpName, vt);
  312. }
  314. BOOL CGuiRecordSet::SetValue(LPCTSTR lpName, COleCurrency cuVal)
  315. {
  316. _variant_t vt;
  317. vt.vt = VT_CY;
  318. vt.cyVal = cuVal.m_cur;
  319. if(cuVal.m_status == COleCurrency::invalid)
  320. return FALSE;
  321. return SetFieldValue(lpName, vt);
  322. }
  324. BOOL CGuiRecordSet::SetFieldValue(LPCTSTR lpName, _variant_t vtField)
  325. {
  326. try
  327. {
  328. m_rs->Fields->GetItem(lpName)->Value = vtField; 
  329. return TRUE;
  330. }
  331. catch(_com_error &e)
  332. {
  333. GetError(e);
  334. return FALSE;
  335. }
  336. }
  339. CString CGuiRecordSet::GetCollect(LPCTSTR lpField)
  340. {
  341. try{
  342. _variant_t vt = m_rs->Fields->GetItem(lpField)->Value;
  343.  return (CString) vt.bstrVal;
  344. }
  345. catch(_com_error &e)
  346. {
  347. GetError(e);
  348. return _T("");
  349. }
  350.  
  351. }
  353. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,int& nValue)
  354. {
  355. _variant_t vt;
  356. try
  357. {
  358. vt = m_rs->Fields->GetItem(lpField)->Value;
  359. if (vt.vt==VT_I2)
  360. {
  361. nValue=vt.intVal;
  362. return TRUE;
  363. }else if (vt.vt==VT_BOOL)
  364. {
  365. nValue=vt.boolVal;
  366. return TRUE;
  367. }else return FALSE;
  368. }catch(_com_error &e)
  369. {
  370. GetError(e);
  371. return FALSE;
  372. }
  373. }
  374. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,long& lVal)
  375. {
  376. _variant_t vt;
  377. try
  378. {
  379. vt = m_rs->Fields->GetItem(lpField)->Value;
  380. if (vt.vt==VT_I4)
  381. {
  382. lVal=vt.lVal;
  383. return TRUE;
  384. }else return FALSE;
  385. }catch(_com_error &e)
  386. {
  387. GetError(e);
  388. return FALSE;
  389. }
  391. }
  392. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,double& dbVal)
  393. {
  394. _variant_t vt;
  395. try
  396. {
  397. vt = m_rs->Fields->GetItem(lpField)->Value;
  398. if (vt.vt==VT_R8)
  399. {
  400. dbVal=vt.dblVal;
  401. return TRUE;
  402. }else return FALSE;
  403. }catch(_com_error &e)
  404. {
  405. GetError(e);
  406. return FALSE;
  407. }
  408. }
  409. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,CString& strValue)
  410. {
  411. _variant_t vt;
  412. try
  413. {
  414. vt = m_rs->Fields->GetItem(lpField)->Value;
  415. if (vt.vt==VT_BSTR)
  416. {
  417. strValue=vt.bstrVal;
  418. return TRUE;
  419. }else return FALSE;
  420. }catch(_com_error &e)
  421. {
  422. GetError(e);
  423. return FALSE;
  424. }
  425. }
  428. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleCurrency& cyVal)
  429. {
  430. _variant_t vt;
  431. vt = m_rs->Fields->GetItem(lpField)->Value;
  433. try
  434. {
  435. if (vt.vt==VT_CY)
  436. {
  437. cyVal.m_cur=vt.cyVal;
  438. return TRUE;
  439. }else return FALSE;
  440. }catch(_com_error &e)
  441. {
  442. GetError(e);
  443. return FALSE;
  444. }
  446. }
  448. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,COleDateTime& dtVal)
  449. {
  450. _variant_t vt;
  451. try
  452. {
  453. vt = m_rs->Fields->GetItem(lpField)->Value;
  454. if (vt.vt==VT_DATE)
  455. {
  456. dtVal=vt.date;
  457. return TRUE;
  458. }else return FALSE;
  459. }catch(_com_error &e)
  460. {
  461. GetError(e);
  462. return FALSE;
  463. }
  464. }
  465. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,float& flVal)
  466. {
  467. _variant_t vt;
  468. try
  469. {
  470. vt = m_rs->Fields->GetItem(lpField)->Value;
  471. if (vt.vt==VT_R4)
  472. {
  473. flVal=vt.fltVal;
  474. return TRUE;
  475. }else return FALSE;
  476. }catch(_com_error &e)
  477. {
  478. GetError(e);
  479. return FALSE;
  480. }
  481. }
  483. BOOL CGuiRecordSet::GetCollect(LPCTSTR lpField,_variant_t& vt)
  484. {
  485. try
  486. {
  487. vt = m_rs->Fields->GetItem(lpField)->Value;
  488. return TRUE;
  489. }
  490. catch(_com_error& e)
  491. {
  492. GetError(e);
  493. return FALSE;
  494. }
  495. }
  497. BOOL CGuiRecordSet::GetCollect(int nIndex,int& nValue)
  498. {
  499. _variant_t vt;
  500. _variant_t vtn;
  501. vtn.vt = VT_I2;
  502. try
  503. {
  504. vtn.iVal = nIndex;
  505. vt = m_rs->Fields->GetItem(vtn)->Value;
  506. if (vt.vt==VT_I2)
  507. {
  508. nValue=vt.intVal;
  509. return TRUE;
  510. }else return FALSE;
  511. }catch(_com_error &e)
  512. {
  513. GetError(e);
  514. return FALSE;
  515. }
  517. }
  519. BOOL CGuiRecordSet::GetCollect(int nIndex,long& lVal)
  520. {
  521. _variant_t vt;
  522. _variant_t vtn;
  523. vtn.vt = VT_I2;
  524. try
  525. {
  526. vtn.iVal = nIndex;
  527. vt = m_rs->Fields->GetItem(vtn)->Value;
  528. if (vt.vt==VT_I4)
  529. {
  530. lVal=vt.lVal;
  531. return TRUE;
  532. }else return FALSE;
  533. }catch(_com_error &e)
  534. {
  535. GetError(e);
  536. return FALSE;
  537. }
  539. }
  541. BOOL CGuiRecordSet::GetCollect(int nIndex,double& dbVal)
  542. {
  543. _variant_t vt;
  544. _variant_t vtn;
  545. vtn.vt = VT_I2;
  546. try
  547. {
  548. vtn.iVal = nIndex;
  549. vt = m_rs->Fields->GetItem(vtn)->Value;
  550. if (vt.vt==VT_R8)
  551. {
  552. dbVal=vt.dblVal;
  553. return TRUE;
  554. }else return FALSE;
  555. }catch(_com_error &e)
  556. {
  557. GetError(e);
  558. return FALSE;
  559. }
  560. }
  562. BOOL CGuiRecordSet::GetCollect(int nIndex,CString& strValue)
  563. {
  564. _variant_t vt;
  565. _variant_t vtn;
  566. vtn.vt = VT_I2;
  567. try
  568. {
  569. vtn.iVal = nIndex;
  570. vt = m_rs->Fields->GetItem(vtn)->Value;
  571. if (vt.vt==VT_BSTR)
  572. {
  573. strValue=vt.bstrVal;
  574. return TRUE;
  575. }else return FALSE;
  576. }catch(_com_error &e)
  577. {
  578. GetError(e);
  579. return FALSE;
  580. }
  581. }
  583. BOOL CGuiRecordSet::GetCollect(int nIndex,COleCurrency& cyVal)
  584. {
  585. _variant_t vt;
  586. _variant_t vtn;
  587. vtn.vt = VT_CY;
  588. try
  589. {
  590. vtn.iVal =nIndex;
  591. vt = m_rs->Fields->GetItem(vtn)->Value;
  592. if (vt.vt==VT_CY)
  593. {
  594. cyVal.m_cur=vt.cyVal;
  595. return TRUE;
  596. }else return FALSE;
  597. }catch(_com_error &e)
  598. {
  599. GetError(e);
  600. return FALSE;
  601. }
  603. }
  605. BOOL CGuiRecordSet::GetCollect(int nIndex,COleDateTime& dtVal)
  606. {
  607. _variant_t vt;
  608. _variant_t vtn;
  609. vtn.vt = VT_I2;
  610. try
  611. {
  612. vtn.iVal = nIndex;
  613. vt = m_rs->Fields->GetItem(vtn)->Value;
  614. if (vt.vt==VT_DATE)
  615. {
  616. dtVal=vt.date;
  617. return TRUE;
  618. }else return FALSE;
  619. }catch(_com_error &e)
  620. {
  621. GetError(e);
  622. return FALSE;
  623. }
  625. }
  627. BOOL CGuiRecordSet::GetFormatDate(LPCTSTR lpField,CString& m_szDate, CString Format)
  628. {
  629. COleDateTime time;
  630. if (!GetCollect(lpField,time)) return FALSE;
  631. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  632. m_szDate =ct.Format(Format);
  633. return TRUE;
  634. }
  636. BOOL CGuiRecordSet::GetFormatDate(int nIndex,CString& m_szDate, CString Format)
  637. {
  638. COleDateTime time;
  639. if (!GetCollect(nIndex,time)) return FALSE;
  640. CTime ct(time.GetYear(),time.GetMonth(),time.GetDay(),time.GetHour(),time.GetMinute(),time.GetSecond()); 
  641. m_szDate =ct.Format(Format);
  642. return TRUE;
  643. }
  645. BOOL CGuiRecordSet::GetCollect(int nIndex,float& flVal)
  646. {
  647. _variant_t vt;
  648. _variant_t vtn;
  649. vtn.vt = VT_I2;
  650. try
  651. {
  652. vtn.iVal = nIndex;
  653. vt = m_rs->Fields->GetItem(vtn)->Value;
  654. if (vt.vt==VT_R4)
  655. {
  656. flVal=vt.fltVal;
  657. return TRUE;
  658. }else return FALSE;
  659. }catch(_com_error &e)
  660. {
  661. GetError(e);
  662. return FALSE;
  663. }
  665. }
  669. BOOL CGuiRecordSet::GetCollect(int nIndex,_variant_t& vt)
  670. {
  672. _variant_t vtn;
  673. vtn.vt = VT_I2;
  674. try
  675. {
  676. vtn.iVal = nIndex;
  677. vt = m_rs->Fields->GetItem(vtn)->Value;
  678. return TRUE;
  679. }
  680. catch(_com_error& e)
  681. {
  682. GetError(e);
  683. return FALSE;
  684. }
  685. }
  690. BOOL CGuiRecordSet::SetFilter(LPCTSTR lpFilter)
  691. {
  692. if (!IsOpen()) return FALSE;
  693. try
  694. {
  695. m_rs->PutFilter(lpFilter);
  696. return TRUE;
  697. }
  698. catch(_com_error &e)
  699. {
  700. GetError(e);
  701. return FALSE;
  702. }
  703. }
  705. BOOL CGuiRecordSet::SetSort(LPCTSTR lpSort)
  706. {
  707. if (!IsOpen()) return FALSE;
  708. try
  709. {
  710. m_rs->PutSort(lpSort);
  711. return TRUE;
  712. }
  713. catch(_com_error &e)
  714. {
  715. GetError(e);
  716. return FALSE;
  717. }
  718. }
  721. BOOL CGuiRecordSet::IsOpen()
  722. {
  723. if(m_rs)
  724. return m_rs-> GetState() != adStateClosed;
  725. return FALSE;
  726. }
  728. void CGuiRecordSet::Close()
  729. {
  730. if(IsOpen())
  731. m_rs->Close();
  733. }
  736. void CGuiRecordSet::MoveFirst()
  737. {
  738. m_rs->MoveFirst();
  739. }
  741. void CGuiRecordSet::MoveLast()
  742. {
  743. m_rs->MoveLast();
  744. }
  746. void CGuiRecordSet::MoveNext()
  747. {
  748. m_rs->MoveNext();
  749. }
  751. void CGuiRecordSet::MovePrevious()
  752. {
  753. m_rs->MovePrevious();
  754. }
  756. void CGuiRecordSet::Cancel()
  757. {
  758.    m_rs->Cancel();
  759. }
  761. void CGuiRecordSet::CancelUpdate()
  762. {
  763.   m_rs->CancelUpdate();
  764. }
  766. BOOL CGuiRecordSet::Delete()
  767. {
  768. try{
  769. if(m_rs->Delete(adAffectCurrent)== S_OK)
  770. if(m_rs->Update() ==S_OK)
  771. return TRUE;
  772. }catch(_com_error &e)
  773. {
  774. GetError(e);
  775. return FALSE;
  776. }
  777. return FALSE;
  778. }
  780. BOOL CGuiRecordSet::IsEof()
  781. {
  782. return (BOOL)m_rs->EndOfFile;
  783. }
  784. BOOL CGuiRecordSet::IsBof()
  785. {
  786. return (BOOL)m_rs->BOF;
  787. }
  788. BOOL CGuiRecordSet::Supports( CursorOptionEnum CursorOptions )  {   return (BOOL)m_rs->Supports(CursorOptions); }
  789. void CGuiRecordSet::CancelBatch(AffectEnum AffectRecords) {   m_rs->CancelBatch(AffectRecords); } CGuiField CGuiRecordSet::GetField(LPCTSTR lpField)
  790. {
  791. FieldPtr pField = m_rs->Fields->GetItem(lpField);
  792. CGuiField Field;
  793. Field.Attach(pField);
  794. return Field;
  795. }
  796. CGuiField CGuiRecordSet::GetField(int Index) { _variant_t vtIndex;
  797. vtIndex.vt = VT_I2;
  798. vtIndex.iVal = Index;
  799. FieldPtr pField = m_rs->Fields->GetItem(vtIndex); CGuiField Field;
  800. Field.Attach(pField);
  801. 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;  }
  802. //***********************************************************************************************************
  803. CGuiField::CGuiField(void)
  804. {
  805. }
  806. CGuiField::~CGuiField(void)
  807. {
  808. }
  809. BOOL CGuiField::SetValue(long lVal)
  810. {
  811. _variant_t vt;
  812. vt.lVal=lVal;
  813. vt.vt=VT_I4;
  814. try
  815. {
  816. field->Value=vt;
  817. return TRUE;
  818. }catch(_com_error &e)
  819. {
  820. GetError(e);
  821. return FALSE;
  822. }
  824. }
  828. BOOL CGuiField::SetValue(float flVal)
  829. {
  830. _variant_t vt;
  831. vt.fltVal=flVal;
  832. vt.vt=VT_R4;
  833. try
  834. {
  835. field->Value=vt;
  836. return TRUE;
  837. }catch(_com_error &e)
  838. {
  839. GetError(e);
  840. return FALSE;
  841. }
  842. }
  845. BOOL CGuiField::SetValue(int nVal)
  846. {
  847. _variant_t vt;
  848. vt.intVal=nVal;
  849. vt.vt=VT_I2;
  850. try
  851. {
  852. field->Value=vt;
  853. return TRUE;
  854. }catch(_com_error &e)
  855. {
  856. GetError(e);
  857. return FALSE;
  858. }
  861. }
  863. BOOL CGuiField::SetValue(double dbVal)
  864. {
  865. _variant_t vt;
  866. vt.dblVal=dbVal;
  867. vt.vt=VT_R8;
  869. try
  870. {
  871. field->Value=vt;
  872. return TRUE;
  873. }catch(_com_error &e)
  874. {
  875. GetError(e);
  876. return FALSE;
  877. }
  879. }
  881. BOOL CGuiField::SetValue(CString szCad)
  882. {
  883. _variant_t vt;
  884. if(!szCad.IsEmpty())
  885. {
  886. vt.vt = VT_BSTR;
  887. vt.bstrVal = szCad.AllocSysString();
  888. }
  889. try
  890. {
  891. field->Value=vt;
  892. return TRUE;
  893. }catch(_com_error &e)
  894. {
  895. GetError(e);
  896. return FALSE;
  897. }
  900. }
  903. BOOL CGuiField::SetValue(bool blVal)
  904. {
  905. _variant_t vt;
  906. vt.boolVal=blVal;
  907. vt.vt=VT_BOOL;
  908. try
  909. {
  910. field->Value=vt;
  911. return TRUE;
  912. }catch(_com_error &e)
  913. {
  914. GetError(e);
  915. return FALSE;
  916. }
  917. }
  920. BOOL CGuiField::SetValue(COleDateTime dtVal)
  921. {
  922. _variant_t vt;
  923. vt.date=dtVal;
  924. vt.vt=VT_DATE;
  925. try
  926. {
  927. field->Value=vt;
  928. return TRUE;
  929. }catch(_com_error &e)
  930. {
  931. GetError(e);
  932. return FALSE;
  933. }
  935. }
  937. BOOL CGuiField::SetValue(_variant_t vt)
  938. {
  939. try
  940. {
  941. field->Value=vt;
  942. return TRUE;
  943. }catch(_com_error &e)
  944. {
  945. GetError(e);
  946. return FALSE;
  947. }
  949. }
  951. BOOL CGuiField::GetValue(int& nVal)
  952. {
  953. _variant_t vt;
  954. vt = field->Value;
  955. try
  956. {
  957. if (vt.vt==VT_I2)
  958. {
  959. nVal=vt.intVal;
  960. return TRUE;
  961. }else if (vt.vt==VT_BOOL)
  962. {
  963. nVal=vt.boolVal;
  964. return TRUE;
  965. }else return FALSE;
  966. }catch(_com_error &e)
  967. {
  968. GetError(e);
  969. return FALSE;
  970. }
  972. }
  974. BOOL CGuiField::GetValue(long& lVal)
  975. {
  976. _variant_t vt;
  977. vt = field->Value;
  978. try
  979. {
  980. if (vt.vt==VT_I4)
  981. {
  982. lVal=vt.lVal;
  983. return TRUE;
  984. }else return FALSE;
  985. }catch(_com_error &e)
  986. {
  987. GetError(e);
  988. return FALSE;
  989. }
  991. }
  993. BOOL CGuiField::GetValue(double& dbVal)
  994. {
  995. _variant_t vt;
  996. vt = field->Value;
  997. try
  998. {
  999. if (vt.vt==VT_R8)
  1000. {
  1001. dbVal=vt.dblVal;
  1002. return TRUE;
  1003. }else return FALSE;
  1004. }catch(_com_error &e)
  1005. {
  1006. GetError(e);
  1007. return FALSE;
  1008. }
  1009. }
  1011. BOOL CGuiField::GetValue(CString& strValue)
  1012. {
  1013. _variant_t vt;
  1014. vt =field->Value;
  1016. try
  1017. {
  1018. if (vt.vt==VT_BSTR)
  1019. {
  1020. strValue=vt.bstrVal;
  1021. return TRUE;
  1022. }else return FALSE;
  1023. }catch(_com_error &e)
  1024. {
  1025. GetError(e);
  1026. return FALSE;
  1027. }
  1028. }
  1030. BOOL CGuiField::GetValue(COleDateTime& dtVal)
  1031. {
  1032. _variant_t vt;
  1033. vt = field->Value;
  1034. try
  1035. {
  1036. if (vt.vt==VT_DATE)
  1037. {
  1038. dtVal=vt.date;
  1039. return TRUE;
  1040. }else return FALSE;
  1041. }catch(_com_error &e)
  1042. {
  1043. GetError(e);
  1044. return FALSE;
  1045. }
  1047. }
  1049. BOOL CGuiField::GetValue(float& flVal)
  1050. {
  1051. _variant_t vt;
  1052. vt = field->Value;
  1053. try
  1054. {
  1055. if (vt.vt==VT_R4)
  1056. {
  1057. flVal=vt.fltVal;
  1058. return TRUE;
  1059. }else return FALSE;
  1060. }catch(_com_error &e)
  1061. {
  1062. GetError(e);
  1063. return FALSE;
  1064. }
  1066. }
  1070. BOOL CGuiField::GetValue(_variant_t& vt)
  1071. {
  1072. try
  1073. {
  1074. //_variant_t vt = field->Value;
  1075. 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. }