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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
ListExportDlg.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：32k
源码类别：

金融证券系统

开发平台：

Visual C++

ListExportDlg.cpp：源码内容
  1. // ListExportDlg.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  6. #include "ListExportDlg.h"
  7. #include <io.h>
  9. #ifdef _DEBUG
  10. #define new DEBUG_NEW
  11. #undef THIS_FILE
  12. static char THIS_FILE[] = __FILE__;
  13. #endif
  15. /////////////////////////////////////////////////////////////////////////////
  16. // class CExportDB
  18. CExportDB::CExportDB( )
  19. {
  20. m_pTableDef = NULL;
  21. m_pRecord = NULL;
  22. }
  24. CExportDB::~CExportDB( )
  25. {
  26. CloseAllDB( );
  27. }
  29. CString CExportDB::ESCString( CString &string )
  30. {
  31. CString strResult;
  32. for( int i=0; i<string.GetLength(); i++ )
  33. {
  34. char ch = string.GetAt(i);
  35. if( ch == '\' || ch == ''' )
  36. strResult += "\";
  37. strResult += ch;
  38. }
  39. return strResult;
  40. }
  42. CString CExportDB::ESCCSVString( CString &string )
  43. {
  44. CString strResult;
  45. for( int i=0; i<string.GetLength(); i++ )
  46. {
  47. char ch = string.GetAt(i);
  48. if( ch == '\' || ch == ''' || ch == ',' )
  49. strResult += "\";
  50. strResult += ch;
  51. }
  52. return strResult;
  53. }
  55. BOOL CExportDB::ExecuteODBCFile( CString strODBCDest )
  56. {
  57. if( -1 != strODBCDest.Find( "DSN=Excel" )
  58. || -1 != strODBCDest.Find( "DSN=MS Access Database" ) )
  59. {
  60. int nIndex = strODBCDest.Find( "DBQ=" );
  61. if( -1 != nIndex )
  62. {
  63. CString strDBQ = strODBCDest.Mid( nIndex+4 );
  64. nIndex = strDBQ.Find( ";" );
  65. if( -1 != nIndex )
  66. strDBQ = strDBQ.Left( nIndex );
  67. ShellExecute( NULL, "open", strDBQ, NULL, NULL, SW_SHOW );
  68. return TRUE;
  69. }
  70. }
  71. else
  72. {
  73. int nIndex = strODBCDest.Find( "DefaultDir=" );
  74. if( -1 != nIndex )
  75. {
  76. CString strDefaultDir = strODBCDest.Mid( nIndex + 11 );
  77. nIndex = strDefaultDir.Find( ";" );
  78. if( -1 != nIndex )
  79. strDefaultDir = strDefaultDir.Left( nIndex );
  80. ShellExecute( NULL, "open", strDefaultDir, NULL, NULL, SW_SHOW );
  81. return TRUE;
  82. }
  83. }
  84. return FALSE;
  85. }
  87. BOOL CExportDB::SetTableColumn( CStringArray & astrColumnName, CUIntArray & anWidth )
  88. {
  89. ASSERT( astrColumnName.GetSize() == anWidth.GetSize() );
  90. if( astrColumnName.GetSize() != anWidth.GetSize() )
  91. return FALSE;
  93. m_astrColumnName.Copy( astrColumnName );
  94. m_anColumnWidth.Copy( anWidth );
  95. ASSERT( m_astrColumnName.GetSize() > 0 );
  96. return m_astrColumnName.GetSize() > 0;
  97. }
  99. BOOL CExportDB::OpenTxtDB( LPCTSTR lpszTxtDest, BOOL bTxtPath )
  100. {
  101. if( NULL == lpszTxtDest || strlen(lpszTxtDest) <= 0 )
  102. {
  103. ASSERT( FALSE );
  104. return FALSE;
  105. }
  106. if( bTxtPath && FILE_ATTRIBUTE_DIRECTORY != GetFileAttributes( lpszTxtDest ) )
  107. {
  108. ASSERT( FALSE );
  109. return FALSE;
  110. }
  112. CloseTxtDB( );
  113. m_strTxtDest = lpszTxtDest;
  114. m_bTxtPath = bTxtPath;
  115. return TRUE;
  116. }
  118. BOOL CExportDB::OpenTxtTable( LPCTSTR lpszTableName, BOOL bOverwrite )
  119. {
  120. if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
  121. {
  122. ASSERT( FALSE );
  123. return FALSE;
  124. }
  126. if( m_strTxtDest.GetLength() == 0 /* Txt DB Not Open */
  127. || m_astrColumnName.GetSize() == 0 /* Not Set Table Column */ )
  128. {
  129. ASSERT( FALSE );
  130. return FALSE;
  131. }
  133. // Path Txt DB
  134. if( m_bTxtPath && FILE_ATTRIBUTE_DIRECTORY != GetFileAttributes( m_strTxtDest ) )
  135. {
  136. ASSERT( FALSE );
  137. return FALSE;
  138. }
  140. CloseTxtTable( );
  142. // Path Txt DB
  143. CString strTxtFile = m_strTxtDest;
  144. if( m_bTxtPath )
  145. strTxtFile = m_strTxtDest + lpszTableName + ".txt";
  147. UINT nOpenFlags = CFile::modeCreate | CFile::modeWrite;
  148. if( !bOverwrite )
  149. nOpenFlags |= CFile::modeNoTruncate;
  150. if( !m_fileTxt.Open( strTxtFile, nOpenFlags ) )
  151. return FALSE;
  153. m_fileTxt.SeekToEnd();
  155. if( bOverwrite )
  156. {
  157. m_fileTxt.WriteString( CString(lpszTableName) + "n"/*STRING_CRLF*/ );
  159. int nStrLenTotal = 0, cxTotal = 0;
  160. for( int nCol=0; nCol < m_astrColumnName.GetSize(); nCol ++ )
  161. {
  162. int nColWidth = m_anColumnWidth[nCol];
  163. CString strText = m_astrColumnName.ElementAt(nCol);
  164. strText += " ";
  165. while( ( (nStrLenTotal+strText.GetLength()) * 6 ) < cxTotal+nColWidth )
  166. strText = " " + strText;
  168. m_fileTxt.WriteString( strText );
  169. nStrLenTotal += strText.GetLength();
  170. cxTotal += nColWidth;
  171. }
  172. m_fileTxt.WriteString( "n"/*STRING_CRLF*/ );
  173. }
  174. return TRUE;
  175. }
  177. BOOL CExportDB::OpenMdbDB( LPCTSTR lpszMdbDest )
  178. {
  179. if( NULL == lpszMdbDest || strlen(lpszMdbDest) <= 0 )
  180. {
  181. ASSERT( FALSE );
  182. return FALSE;
  183. }
  185. TRY
  186. {
  187. CloseMdbDB( );
  189. if( 0 == access( lpszMdbDest, 0 ) )
  190. m_mdb.Open( lpszMdbDest );
  191. else
  192. m_mdb.Create( lpszMdbDest );
  193. }
  194. CATCH( CDaoException, e )
  195. {
  196. CloseMdbDB();
  197. e->ReportError( );
  198. return FALSE;
  199. }
  200. END_CATCH
  202. return m_mdb.IsOpen();
  203. }
  205. BOOL CExportDB::OpenMdbTable( LPCTSTR lpszTableName, BOOL bOverwrite )
  206. {
  207. if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
  208. {
  209. ASSERT( FALSE );
  210. return FALSE;
  211. }
  212. TRY
  213. {
  214. if( !m_mdb.IsOpen() || m_astrColumnName.GetSize() <= 0 )
  215. {
  216. ASSERT( FALSE );
  217. return FALSE;
  218. }
  219. CloseMdbTable();
  221. CString strTableName = lpszTableName;
  223. BOOL bCreateNew = bOverwrite;
  224. if( !bOverwrite )
  225. {
  226. try {
  227. CDaoTableDefInfo tabledefinfo;
  228. m_mdb.GetTableDefInfo( strTableName, tabledefinfo );
  230. CDaoTableDef tabledef( &m_mdb );
  231. tabledef.Open( strTableName );
  232. if( !tabledef.IsOpen() )
  233. bCreateNew = TRUE;
  234. else
  235. {
  236. if( m_astrColumnName.GetSize() != tabledef.GetFieldCount() )
  237. bCreateNew = TRUE;
  238. CDaoFieldInfo fieldinfo;
  239. for( int i=0; i<tabledef.GetFieldCount(); i++ )
  240. {
  241. tabledef.GetFieldInfo( i, fieldinfo, AFX_DAO_ALL_INFO );
  242. bCreateNew |= ( 0 != fieldinfo.m_strName.Compare(m_astrColumnName[i]) );
  243. bCreateNew |= ( dbText != fieldinfo.m_nType );
  244. bCreateNew |= ( 255 != fieldinfo.m_lSize );
  245. bCreateNew |= (! ( (dbVariableField | dbUpdatableField) & fieldinfo.m_lAttributes) );
  246. }
  247. tabledef.Close();
  248. }
  249. }catch( CDaoException * e ) {
  250. e->Delete();
  251. bCreateNew = TRUE;
  252. }
  253. }
  255. if( bCreateNew )
  256. {
  257. // Create New Table
  258. int nCount = 1;
  259. while( TRUE )
  260. {
  261. try {
  262. if( 1 != nCount )
  263. strTableName.Format( "%s%d", lpszTableName, nCount );
  264. CDaoTableDefInfo tabledefinfo;
  265. m_mdb.GetTableDefInfo( strTableName, tabledefinfo );
  266. }catch ( CDaoException * e){
  267. e->Delete();
  268. break;
  269. }
  270. nCount ++;
  271. }
  273. // create strTableName.
  274. CDaoTableDef tabledef( &m_mdb );
  275. tabledef.Create( strTableName );
  277. // def strTableName's field.
  278. CDaoFieldInfo fieldinfo;
  280. fieldinfo.m_bRequired = false;
  281. fieldinfo.m_lCollatingOrder = dbSortGeneral;
  282. fieldinfo.m_strSourceTable = strTableName;
  283. for( int i=0; i<m_astrColumnName.GetSize(); i++ )
  284. {
  285. fieldinfo.m_bAllowZeroLength = true;
  286. fieldinfo.m_nOrdinalPosition = i+1;
  287. fieldinfo.m_strName = ESCString(m_astrColumnName[i]);
  288. fieldinfo.m_lSize = 255;
  289. fieldinfo.m_nType = dbText;
  290. fieldinfo.m_lAttributes = dbVariableField | dbUpdatableField;
  291. fieldinfo.m_strSourceField = ESCString(m_astrColumnName[i]);
  292. tabledef.CreateField( fieldinfo );
  293. }
  294. tabledef.Append( );
  295. tabledef.Close( );
  296. // CreateNew End
  297. }
  299. // Open Table
  300. if( !m_mdb.IsOpen( ) )
  301. return FALSE;
  302. m_pTableDef = new CDaoTableDef( &m_mdb );
  303. m_pTableDef->Open( strTableName );
  304. m_pRecord = new CDaoRecordset( &m_mdb );
  305. m_pRecord->Open( m_pTableDef, dbOpenDynaset );
  306. if( !m_pRecord->IsOpen() || !m_pTableDef->IsOpen() )
  307. {
  308. CloseMdbTable();
  309. return FALSE;
  310. }
  311. }
  312. CATCH( CDaoException, e )
  313. {
  314. CloseMdbTable();
  315. e->ReportError( );
  316. return FALSE;
  317. }
  318. END_CATCH
  320. return TRUE;
  321. }
  323. BOOL CExportDB::OpenCsvDB( LPCTSTR lpszCsvDest, BOOL bCsvPath )
  324. {
  325. if( NULL == lpszCsvDest || strlen(lpszCsvDest) <= 0 )
  326. {
  327. ASSERT( FALSE );
  328. return FALSE;
  329. }
  330. if( bCsvPath && FILE_ATTRIBUTE_DIRECTORY != GetFileAttributes( lpszCsvDest ) )
  331. {
  332. ASSERT( FALSE );
  333. return FALSE;
  334. }
  336. CloseCsvDB( );
  337. m_strCsvDest = lpszCsvDest;
  338. m_bCsvPath = bCsvPath;
  339. return TRUE;
  340. }
  342. BOOL CExportDB::OpenCsvTable( LPCTSTR lpszTableName, BOOL bOverwrite )
  343. {
  344. if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
  345. {
  346. ASSERT( FALSE );
  347. return FALSE;
  348. }
  350. if( m_strCsvDest.GetLength() == 0 /* Csv DB Not Open */
  351. || m_astrColumnName.GetSize() == 0 /* Not Set Table Column */ )
  352. {
  353. ASSERT( FALSE );
  354. return FALSE;
  355. }
  357. // Path Csv DB
  358. if( m_bCsvPath && FILE_ATTRIBUTE_DIRECTORY != GetFileAttributes( m_strCsvDest ) )
  359. {
  360. ASSERT( FALSE );
  361. return FALSE;
  362. }
  364. CloseCsvTable( );
  366. CString strCsvFile = m_strCsvDest;
  367. if( m_bCsvPath )
  368. strCsvFile = m_strCsvDest + lpszTableName + ".csv";
  370. UINT nOpenFlags = CFile::modeCreate | CFile::modeWrite;
  371. if( !bOverwrite )
  372. nOpenFlags |= CFile::modeNoTruncate;
  373. if( !m_fileCsv.Open( strCsvFile, nOpenFlags ) )
  374. {
  375. return FALSE;
  376. }
  378. m_fileCsv.SeekToEnd();
  380. if( bOverwrite )
  381. {
  382. m_fileCsv.WriteString( CString(lpszTableName) + "n" );
  384. CString strText;
  385. for( int nCol=0; nCol < m_astrColumnName.GetSize(); nCol ++ )
  386. {
  387. int nColWidth = m_anColumnWidth[nCol];
  388. if( strText.GetLength() > 0 )
  389. strText += ",";
  390. strText += m_astrColumnName.ElementAt(nCol);
  391. }
  392. m_fileCsv.WriteString( strText );
  393. m_fileCsv.WriteString( "n" );
  394. }
  395. return TRUE;
  396. }
  398. BOOL CExportDB::OpenODBCDB( LPCTSTR lpszDSN )
  399. {
  400. TRY
  401. {
  402. CloseODBCDB( );
  404. if( !m_dbODBC.Open(lpszDSN, FALSE, FALSE, _T("ODBC;"), FALSE) )
  405. return FALSE;
  407. return TRUE;
  408. }
  409. CATCH(CException, e)
  410. {
  411. CloseODBCDB( );
  412. if(e) e->ReportError( );
  413. return FALSE;
  414. }
  415. END_CATCH
  416. }
  418. BOOL CExportDB::OpenODBCTable( LPCTSTR lpszTableName, BOOL bOverwrite )
  419. {
  420. if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
  421. {
  422. ASSERT( FALSE );
  423. return FALSE;
  424. }
  425. TRY
  426. {
  427. if( !m_dbODBC.IsOpen() || m_astrColumnName.GetSize() <= 0 )
  428. {
  429. ASSERT( FALSE );
  430. return FALSE;
  431. }
  432. CloseODBCTable();
  434. // Get Next Table Name
  435. CString strTableName = lpszTableName;
  437. BOOL bCreateNew = bOverwrite;
  438. if( !bOverwrite )
  439. {
  440. try {
  441. CRecordset rec( &m_dbODBC );
  442. if( !rec.Open( CRecordset::dynaset, "SELECT * FROM "" + strTableName + """ ) )
  443. bCreateNew = TRUE;
  444. else
  445. {
  446. if( m_astrColumnName.GetSize() != rec.GetODBCFieldCount() )
  447. bCreateNew = TRUE;
  448. CODBCFieldInfo fieldinfo;
  449. for( int i=0; i<rec.GetODBCFieldCount(); i++ )
  450. {
  451. rec.GetODBCFieldInfo( i, fieldinfo );
  452. bCreateNew |= ( 0 != fieldinfo.m_strName.Compare(m_astrColumnName[i]) );
  453. }
  454. rec.Close();
  455. }
  456. }catch( CDaoException * e) {
  457. e->Delete();
  458. bCreateNew = TRUE;
  459. }
  460. }
  462. if( bCreateNew )
  463. {
  464. // Craete New Table
  465. int nCount = 1;
  466. while( TRUE )
  467. {
  468. try {
  469. if( 1 != nCount )
  470. strTableName.Format( "%s%d", lpszTableName, nCount );
  471. CRecordset rec( &m_dbODBC );
  472. if( !rec.Open( CRecordset::dynaset, "SELECT * FROM "" + strTableName + """ ) )
  473. break;
  474. rec.Close( );
  475. }catch ( CDBException * e ){
  476. e->Delete();
  477. break;
  478. }
  479. nCount ++;
  480. }
  482. // Create Table
  483. CString sqlCreateTable = "CREATE TABLE "" + strTableName + "" (";
  484. for( int k=0; k<m_astrColumnName.GetSize(); k++ )
  485. sqlCreateTable += ( """ + ESCString(m_astrColumnName[k]) + """ + ( k==m_astrColumnName.GetSize()-1 ? " VARCHAR(255))" : " VARCHAR(255)," ) );
  486. m_dbODBC.ExecuteSQL( sqlCreateTable );
  487. // CreateNew End
  488. }
  490. m_strODBCTableName = strTableName;
  492. // Test
  493. CRecordset rs( &m_dbODBC );
  494. if( !rs.Open( CRecordset::dynaset, "SELECT * FROM "" + strTableName + """ ) )
  495. return FALSE;
  496. rs.Close();
  497. return TRUE;
  498. }
  499. CATCH(CException, e)
  500. {
  501. CloseODBCTable( );
  502. if(e) e->ReportError( );
  503. return FALSE;
  504. }
  505. END_CATCH
  506. }
  508. BOOL CExportDB::AddItemTxt( CStringArray &astrItemText )
  509. {
  510. if( CFile::hFileNull != m_fileTxt.m_hFile )
  511. {
  512. m_fileTxt.SeekToEnd();
  513. int nStrLenTotal = 0, cxTotal = 0;
  514. for( int nCol=0; nCol < astrItemText.GetSize() && nCol < m_anColumnWidth.GetSize(); nCol ++ )
  515. {
  516. int nColWidth = m_anColumnWidth[nCol];
  517. CString strText = astrItemText.ElementAt(nCol);
  518. strText = " " + strText;
  519. while( ( (nStrLenTotal+strText.GetLength()) * 6 ) < cxTotal+nColWidth )
  520. strText = " " + strText;
  522. m_fileTxt.WriteString( strText );
  523. nStrLenTotal += strText.GetLength();
  524. cxTotal += nColWidth;
  525. }
  526. m_fileTxt.WriteString( "n"/*STRING_CRLF*/ );
  527. return TRUE;
  528. }
  529. return FALSE;
  530. }
  532. BOOL CExportDB::AddItemMdb( CStringArray &astrItemText )
  533. {
  534. TRY {
  535. if( m_pRecord && m_pRecord->IsOpen() && m_mdb.IsOpen() )
  536. {
  537. m_pRecord->AddNew( );
  538. for( int i=0; i<astrItemText.GetSize(); i++ )
  539. {
  540. CString strText = astrItemText.ElementAt(i);
  541. if( strText.GetLength() >= 255 )
  542. strText = strText.Left( 254 );
  543. if( strText.GetLength() > 0 && strText.GetLength() < 255 )
  544. m_pRecord->SetFieldValue( i, LPCTSTR(ESCString(strText)) );
  545. }
  546. m_pRecord->Update( );
  547. return TRUE;
  548. }
  549. }CATCH( CException, e ) {
  550. e->Delete();
  551. }END_CATCH
  552. return FALSE;
  553. }
  555. BOOL CExportDB::AddItemCsv( CStringArray &astrItemText )
  556. {
  557. if( CFile::hFileNull != m_fileCsv.m_hFile )
  558. {
  559. m_fileCsv.SeekToEnd();
  560. CString strText;
  561. for( int nCol=0; nCol < astrItemText.GetSize() && nCol < m_anColumnWidth.GetSize(); nCol ++ )
  562. {
  563. int nColWidth = m_anColumnWidth[nCol];
  564. if( strText.GetLength() > 0 )
  565. strText += ",";
  566. strText += ESCCSVString(astrItemText.ElementAt(nCol));
  567. }
  568. m_fileCsv.WriteString( strText );
  569. m_fileCsv.WriteString( "n" );
  570. return TRUE;
  571. }
  572. return FALSE;
  573. }
  575. BOOL CExportDB::AddItemODBC( CStringArray &astrItemText )
  576. {
  577. if( m_dbODBC.IsOpen() )
  578. {
  579. CString sqlInsert = "INSERT INTO "" + m_strODBCTableName + "" VALUES(";
  580. for( int k=0; k<astrItemText.GetSize(); k++ )
  581. sqlInsert += ( "'" + ESCString(astrItemText[k]) + ( k==astrItemText.GetSize()-1 ? "')" : "'," ) );
  583. TRY {
  584. m_dbODBC.ExecuteSQL( sqlInsert );
  585. return TRUE;
  586. } CATCH ( CException, e ) {
  587. e->Delete();
  588. } END_CATCH
  589. }
  590. return FALSE;
  591. }
  593. void CExportDB::CloseTxtDB( )
  594. {
  595. CloseTxtTable();
  596. m_strTxtDest.Empty();
  597. m_bTxtPath = FALSE;
  598. }
  600. void CExportDB::CloseTxtTable( )
  601. {
  602. if( CFile::hFileNull != m_fileTxt.m_hFile )
  603. m_fileTxt.Close();
  604. }
  606. void CExportDB::CloseMdbDB( )
  607. {
  608. try
  609. {
  610. CloseMdbTable();
  611. if( m_mdb.IsOpen() )
  612. m_mdb.Close();
  613. }
  614. catch( CDaoException * e )
  615. {
  616. e->Delete();
  617. TRACE( "Close Mdb Exceptionn" );
  618. }
  619. }
  621. void CExportDB::CloseMdbTable( )
  622. {
  623. try
  624. {
  625. if( m_pRecord && m_pRecord->IsOpen() )
  626. m_pRecord->Close();
  627. if( m_pRecord )
  628. {
  629. delete m_pRecord;
  630. m_pRecord = NULL;
  631. }
  632. if( m_pTableDef && m_pTableDef->IsOpen() )
  633. m_pTableDef->Close();
  634. if( m_pTableDef )
  635. {
  636. delete m_pTableDef;
  637. m_pTableDef = NULL;
  638. }
  639. }
  640. catch( CDaoException * e )
  641. {
  642. e->Delete();
  643. TRACE( "Close Mdb Exceptionn" );
  644. }
  645. }
  647. void CExportDB::CloseCsvDB( )
  648. {
  649. CloseCsvTable( );
  650. m_strCsvDest.Empty();
  651. m_bCsvPath = FALSE;
  652. }
  654. void CExportDB::CloseCsvTable( )
  655. {
  656. if( CFile::hFileNull != m_fileCsv.m_hFile )
  657. m_fileCsv.Close();
  658. }
  660. void CExportDB::CloseODBCDB( )
  661. {
  662. try
  663. {
  664. CloseODBCTable( );
  665. if( m_dbODBC.IsOpen() )
  666. m_dbODBC.Close();
  667. }
  668. catch(...)
  669. {
  670. TRACE(_T("Errors occurred.n"));
  671. }
  672. }
  674. void CExportDB::CloseODBCTable( )
  675. {
  676. TRY
  677. {
  678. if( m_dbODBC.IsOpen() )
  679. {
  680. // Close and Reopen to Flush Data
  681. CString strConnect = m_dbODBC.GetConnect();
  682. m_dbODBC.Close();
  683. m_dbODBC.Open( strConnect, FALSE, FALSE, _T("ODBC;"), FALSE);
  684. }
  685. }
  686. CATCH(CException, e)
  687. {
  688. if(e) e->ReportError( );
  689. }
  690. END_CATCH
  691. }
  693. BOOL CExportDB::OpenAllDB(CString strTxt, BOOL bTxtPath, CString strMdb,
  694.   CString strCsv, BOOL bCsvPath, CString strODBC, BOOL bReportError )
  695. {
  696. BOOL bRet = TRUE;
  697. if( strTxt.GetLength() > 0 )
  698. {
  699. bRet &= OpenTxtDB( strTxt, bTxtPath );
  700. if( !bRet && bReportError )
  701. AfxMessageBox( IDS_EXPORTDB_ERRTXTDEST, MB_OK | MB_ICONINFORMATION );
  702. }
  703. if( strMdb.GetLength() > 0 )
  704. {
  705. bRet &= OpenMdbDB( strMdb );
  706. if( !bRet && bReportError )
  707. AfxMessageBox( IDS_EXPORTDB_ERRMDBDEST, MB_OK | MB_ICONINFORMATION );
  708. }
  709. if( strCsv.GetLength() > 0 )
  710. {
  711. bRet &= OpenCsvDB( strCsv, bCsvPath );
  712. if( !bRet && bReportError )
  713. AfxMessageBox( IDS_EXPORTDB_ERRCSVDEST, MB_OK | MB_ICONINFORMATION );
  714. }
  715. if( strODBC.GetLength() > 0 )
  716. {
  717. bRet &= OpenODBCDB( strODBC );
  718. if( !bRet && bReportError )
  719. AfxMessageBox( IDS_EXPORTDB_ERRODBCDEST, MB_OK | MB_ICONINFORMATION );
  720. }
  722. if( !bRet )
  723. CloseAllDB( );
  724. return bRet;
  725. }
  727. BOOL CExportDB::OpenAllTable( LPCTSTR lpszTableName, BOOL bOverwrite, BOOL bReportError )
  728. {
  729. if( NULL == lpszTableName || strlen(lpszTableName) <= 0 )
  730. {
  731. ASSERT( FALSE );
  732. return FALSE;
  733. }
  735. BOOL bRet = TRUE;
  736. if( m_strTxtDest.GetLength() > 0 )
  737. {
  738. bRet &= OpenTxtTable( lpszTableName, bOverwrite );
  739. if( !bRet && bReportError )
  740. AfxMessageBox( IDS_EXPORTDB_ERRTXTDEST, MB_OK | MB_ICONINFORMATION );
  741. }
  742. if( m_mdb.IsOpen() )
  743. {
  744. bRet &= OpenMdbTable( lpszTableName, bOverwrite );
  745. if( !bRet && bReportError )
  746. AfxMessageBox( IDS_EXPORTDB_ERRMDBDEST, MB_OK | MB_ICONINFORMATION );
  747. }
  748. if( m_strCsvDest.GetLength() > 0 )
  749. {
  750. bRet &= OpenCsvTable( lpszTableName, bOverwrite );
  751. if( !bRet && bReportError )
  752. AfxMessageBox( IDS_EXPORTDB_ERRCSVDEST, MB_OK | MB_ICONINFORMATION );
  753. }
  754. if( m_dbODBC.IsOpen() )
  755. {
  756. bRet &= OpenODBCTable( lpszTableName, bOverwrite );
  757. if( !bRet && bReportError )
  758. AfxMessageBox( IDS_EXPORTDB_ERRODBCDEST, MB_OK | MB_ICONINFORMATION );
  759. }
  761. if( !bRet )
  762. CloseAllTable( );
  763. return bRet;
  764. }
  766. BOOL CExportDB::AddItem( CStringArray &astrItemText )
  767. {
  768. BOOL bRet = TRUE;
  769. if( CFile::hFileNull != m_fileTxt.m_hFile )
  770. {
  771. bRet &= AddItemTxt( astrItemText );
  772. }
  773. if( m_pRecord && m_pRecord->IsOpen() && m_mdb.IsOpen() )
  774. {
  775. bRet &= AddItemMdb( astrItemText );
  776. }
  777. if( CFile::hFileNull != m_fileCsv.m_hFile )
  778. {
  779. bRet &= AddItemCsv( astrItemText );
  780. }
  781. if( m_dbODBC.IsOpen() )
  782. {
  783. bRet &= AddItemODBC( astrItemText );
  784. }
  786. return bRet;
  787. }
  789. void CExportDB::CloseAllDB( )
  790. {
  791. CloseTxtDB( );
  792. CloseMdbDB( );
  793. CloseCsvDB( );
  794. CloseODBCDB( );
  795. }
  797. void CExportDB::CloseAllTable( )
  798. {
  799. CloseTxtTable( );
  800. CloseMdbTable( );
  801. CloseCsvTable( );
  802. CloseODBCTable( );
  803. }
  805. /////////////////////////////////////////////////////////////////////////////
  806. // CListExportDlg dialog
  808. void CListExportDlg::StoreProfile( )
  809. {
  810. AfxGetApp()->WriteProfileInt( "listexportdlg", "txtcheck", m_bTxtCheck );
  811. AfxGetApp()->WriteProfileInt( "listexportdlg", "mdbcheck", m_bMdbCheck );
  812. AfxGetApp()->WriteProfileInt( "listexportdlg", "csvcheck", m_bCsvCheck );
  813. AfxGetApp()->WriteProfileInt( "listexportdlg", "odbccheck", m_bODBCCheck );
  814. AfxGetApp()->WriteProfileString( "listexportdlg", "txtdest", m_strTxtDest );
  815. AfxGetApp()->WriteProfileString( "listexportdlg", "mdbdest", m_strMdbDest );
  816. AfxGetApp()->WriteProfileString( "listexportdlg", "csvdest", m_strCsvDest );
  817. AfxGetApp()->WriteProfileString( "listexportdlg", "odbcdest", m_strODBCDest );
  818. AfxGetApp()->WriteProfileInt( "listexportdlg", "exeonfinish", m_bExeOnFinish );
  819. AfxGetApp()->WriteProfileInt( "listexportdlg", "overwrite", m_bOverwrite );
  820. }
  822. void CListExportDlg::LoadProfile( )
  823. {
  824. // Initial Data
  825. m_bTxtCheck = TRUE;
  826. m_bExeOnFinish = TRUE;
  827. m_bOverwrite = TRUE;
  828. m_strTxtDest = AfxGetProfile().GetExportPath() + "StockList.txt";
  829. m_strMdbDest = AfxGetProfile().GetExportPath() + "StockList.mdb";
  830. m_strCsvDest = AfxGetProfile().GetExportPath() + "StockList.csv";
  831. m_strODBCDest = "ODBC;DSN=Excel Files;DBQ="
  832. + AfxGetProfile().GetExportPath()
  833. + "StockList.xls;DefaultDir="
  834. + AfxGetProfile().GetExportPath()
  835. + ";DriverId=790;MaxBufferSize=2048;PageTimeout=5;";
  837. m_bTxtCheck = AfxGetApp()->GetProfileInt( "listexportdlg", "txtcheck", m_bTxtCheck );
  838. m_bMdbCheck = AfxGetApp()->GetProfileInt( "listexportdlg", "mdbcheck", m_bMdbCheck );
  839. m_bCsvCheck = AfxGetApp()->GetProfileInt( "listexportdlg", "csvcheck", m_bCsvCheck );
  840. m_bODBCCheck = AfxGetApp()->GetProfileInt( "listexportdlg", "odbccheck", m_bODBCCheck );
  841. m_strTxtDest = AfxGetApp()->GetProfileString( "listexportdlg", "txtdest", m_strTxtDest );
  842. m_strMdbDest = AfxGetApp()->GetProfileString( "listexportdlg", "mdbdest", m_strMdbDest );
  843. m_strCsvDest = AfxGetApp()->GetProfileString( "listexportdlg", "csvdest", m_strCsvDest );
  844. m_strODBCDest = AfxGetApp()->GetProfileString( "listexportdlg", "odbcdest", m_strODBCDest );
  845. m_bExeOnFinish = AfxGetApp()->GetProfileInt( "listexportdlg", "exeonfinish", m_bExeOnFinish );
  846. m_bOverwrite = AfxGetApp()->GetProfileInt( "listexportdlg", "overwrite", m_bOverwrite );
  847. }
  849. CListExportDlg::CListExportDlg(CWnd* pParent /*=NULL*/)
  850. : CDialog(CListExportDlg::IDD, pParent)
  851. {
  852. //{{AFX_DATA_INIT(CListExportDlg)
  853. m_nItemBegin = 1;
  854. m_nItemEnd = 1;
  855. m_strTxtDest = _T("");
  856. m_strMdbDest = _T("");
  857. m_strCsvDest = _T("");
  858. m_bTxtCheck = FALSE;
  859. m_bMdbCheck = FALSE;
  860. m_bCsvCheck = FALSE;
  861. m_bExeOnFinish = FALSE;
  862. m_bODBCCheck = FALSE;
  863. m_strODBCDest = _T("");
  864. //}}AFX_DATA_INIT
  865. m_nItemMax = 1;
  866. m_bItemAll = FALSE;
  867. m_bItemSelected = FALSE;
  868. m_bItemDefine = FALSE;
  869. }
  871. CListExportDlg::~CListExportDlg( )
  872. {
  873. }
  875. BOOL CListExportDlg::ExportBegin(CStringArray &astrColumnName, CUIntArray &anWidth,
  876. BOOL bReportError )
  877. {
  878. CString strTxt, strMdb, strCsv, strODBC;
  879. if( m_bTxtCheck ) strTxt = m_strTxtDest;
  880. if( m_bMdbCheck ) strMdb = m_strMdbDest;
  881. if( m_bCsvCheck ) strCsv = m_strCsvDest;
  882. if( m_bODBCCheck ) strODBC = m_strODBCDest;
  883. if( !m_exportdb.OpenAllDB(strTxt, FALSE, strMdb, strCsv, FALSE, strODBC,
  884. bReportError ) )
  885. return FALSE;
  887. if( ! m_exportdb.SetTableColumn( astrColumnName, anWidth ) )
  888. return FALSE;
  890. return TRUE;
  891. }
  893. BOOL CListExportDlg::ExportOpenTable(CSPTime &time, BOOL bReportError )
  894. {
  895. CString strTableName;
  896. strTableName.LoadString( IDS_LISTEXPORT_TABLENAME );
  897. strTableName += AfxGetTimeString( time.GetTime(), "%Y-%m-%d-", TRUE );
  898. if( !m_exportdb.OpenAllTable( strTableName, m_bOverwrite, bReportError ) )
  899. return FALSE;
  900. return TRUE;
  901. }
  903. BOOL CListExportDlg::ExportAddItem( CStringArray &astrItemText )
  904. {
  905. return m_exportdb.AddItem( astrItemText );
  906. }
  908. void CListExportDlg::ExportCloseTable( )
  909. {
  910. m_exportdb.CloseAllTable( );
  911. }
  913. BOOL CListExportDlg::ExportFinish( )
  914. {
  915. m_exportdb.CloseAllDB( );
  917. if( m_bExeOnFinish )
  918. {
  919. if( m_bTxtCheck && m_strTxtDest.GetLength() > 0 )
  920. ShellExecute( NULL, "open", m_strTxtDest, NULL, NULL, SW_SHOW );
  921. if( m_bMdbCheck && m_strMdbDest.GetLength() > 0 )
  922. ShellExecute( NULL, "open", m_strMdbDest, NULL, NULL, SW_SHOW );
  923. if( m_bCsvCheck && m_strCsvDest.GetLength() > 0 )
  924. ShellExecute( NULL, "open", m_strCsvDest, NULL, NULL, SW_SHOW );
  925. if( m_bODBCCheck && m_strODBCDest.GetLength() > 0 )
  926. CExportDB::ExecuteODBCFile( m_strODBCDest );
  927. }
  929. // Set Progress
  930. m_ctrlProgress.SetWindowPos( NULL, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE );
  931. int nLower = 0, nUpper = 100;
  932. m_ctrlProgress.GetRange( nLower, nUpper );
  934. if( nUpper > nLower )
  935. {
  936. m_ctrlProgress.SetPos( nUpper );
  937. CString strInfo;
  938. strInfo.LoadString( IDS_EXPORTDB_FINISHED );
  939. m_staticProgress.SetWindowText( strInfo );
  940. }
  942. return TRUE;
  943. }
  945. void CListExportDlg::SetProgressRange( int nLower, int nUpper )
  946. {
  947. if( nUpper > nLower )
  948. {
  949. m_ctrlProgress.SetWindowPos( NULL, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE );
  950. m_ctrlProgress.SetRange32( nLower, nUpper );
  951. }
  952. }
  954. void CListExportDlg::SetProgress( int nPos )
  955. {
  956. int nLower = 0, nUpper = 100;
  957. m_ctrlProgress.GetRange( nLower, nUpper );
  959. if( nUpper > nLower )
  960. {
  961. m_ctrlProgress.SetPos( nPos );
  963. CString strProgressNew;
  964. strProgressNew.Format( "%d%%", 100*nPos/(nUpper-nLower) );
  965. CString strProgressOld;
  966. m_staticProgress.GetWindowText( strProgressOld );
  967. if( 0 != strProgressNew.Compare( strProgressOld ) )
  968. m_staticProgress.SetWindowText( strProgressNew );
  969. }
  970. }
  972. void CListExportDlg::DoDataExchange(CDataExchange* pDX)
  973. {
  974. CDialog::DoDataExchange(pDX);
  975. //{{AFX_DATA_MAP(CListExportDlg)
  976. DDX_Control(pDX, IDCANCEL, m_btnCancel);
  977. DDX_Control(pDX, IDOK, m_btnOK);
  978. DDX_Control(pDX, IDC_ODBC_SOURCE, m_btnODBCSource);
  979. DDX_Control(pDX, IDC_ODBC_DEST, m_editODBCDest);
  980. DDX_Control(pDX, IDC_ODBC_CHECK, m_btnODBCCheck);
  981. DDX_Control(pDX, IDC_STATIC_PROGRESS, m_staticProgress);
  982. DDX_Control(pDX, IDC_PROGRESS, m_ctrlProgress);
  983. DDX_Control(pDX, IDC_CSV_EXPLORER, m_btnCsvExplorer);
  984. DDX_Control(pDX, IDC_CSV_DEST, m_editCsvDest);
  985. DDX_Control(pDX, IDC_CSV_CHECK, m_btnCsvCheck);
  986. DDX_Control(pDX, IDC_MDB_EXPLORER, m_btnMdbExplorer);
  987. DDX_Control(pDX, IDC_MDB_DEST, m_editMdbDest);
  988. DDX_Control(pDX, IDC_MDB_CHECK, m_btnMdbCheck);
  989. DDX_Control(pDX, IDC_TXT_EXPLORER, m_btnTxtExplorer);
  990. DDX_Control(pDX, IDC_TXT_DEST, m_editTxtDest);
  991. DDX_Control(pDX, IDC_TXT_CHECK, m_btnTxtCheck);
  992. DDX_Control(pDX, IDC_ITEM_END, m_editItemEnd);
  993. DDX_Control(pDX, IDC_ITEM_BEGIN, m_editItemBegin);
  994. DDX_Text(pDX, IDC_ITEM_BEGIN, m_nItemBegin);
  995. DDV_MinMaxInt(pDX, m_nItemBegin, 1, m_nItemMax);
  996. DDX_Text(pDX, IDC_ITEM_END, m_nItemEnd);
  997. DDV_MinMaxInt(pDX, m_nItemEnd, 1, m_nItemMax);
  998. DDX_Text(pDX, IDC_TXT_DEST, m_strTxtDest);
  999. DDX_Text(pDX, IDC_MDB_DEST, m_strMdbDest);
  1000. DDX_Text(pDX, IDC_CSV_DEST, m_strCsvDest);
  1001. DDX_Check(pDX, IDC_TXT_CHECK, m_bTxtCheck);
  1002. DDX_Check(pDX, IDC_MDB_CHECK, m_bMdbCheck);
  1003. DDX_Check(pDX, IDC_CSV_CHECK, m_bCsvCheck);
  1004. DDX_Check(pDX, IDC_EXEONFINISH, m_bExeOnFinish);
  1005. DDX_Check(pDX, IDC_ODBC_CHECK, m_bODBCCheck);
  1006. DDX_Text(pDX, IDC_ODBC_DEST, m_strODBCDest);
  1007. //}}AFX_DATA_MAP
  1008. }
  1011. BEGIN_MESSAGE_MAP(CListExportDlg, CDialog)
  1012. //{{AFX_MSG_MAP(CListExportDlg)
  1013. ON_BN_CLICKED(IDC_ITEM_ALL, OnItemAll)
  1014. ON_BN_CLICKED(IDC_ITEM_SELECTED, OnItemSelected)
  1015. ON_BN_CLICKED(IDC_ITEM_DEFINE, OnItemDefine)
  1016. ON_BN_CLICKED(IDC_TXT_CHECK, OnTxtCheck)
  1017. ON_BN_CLICKED(IDC_TXT_EXPLORER, OnTxtExplorer)
  1018. ON_BN_CLICKED(IDC_MDB_CHECK, OnMdbCheck)
  1019. ON_BN_CLICKED(IDC_MDB_EXPLORER, OnMdbExplorer)
  1020. ON_BN_CLICKED(IDC_CSV_CHECK, OnCsvCheck)
  1021. ON_BN_CLICKED(IDC_CSV_EXPLORER, OnCsvExplorer)
  1022. ON_BN_CLICKED(IDC_ODBC_CHECK, OnODBCCheck)
  1023. ON_BN_CLICKED(IDC_ODBC_SOURCE, OnOdbcSource)
  1024. //}}AFX_MSG_MAP
  1025. END_MESSAGE_MAP()
  1027. /////////////////////////////////////////////////////////////////////////////
  1028. // CListExportDlg message handlers
  1030. BOOL CListExportDlg::OnInitDialog() 
  1031. {
  1032. CDialog::OnInitDialog();
  1034. // TODO: Add extra initialization here
  1035. LoadProfile( );
  1036. UpdateData( FALSE );
  1038. // select item
  1039. int nCheckID = IDC_ITEM_ALL;
  1040. if( m_bItemSelected )
  1041. nCheckID = IDC_ITEM_SELECTED;
  1042. else if( m_bItemDefine )
  1043. nCheckID = IDC_ITEM_DEFINE;
  1044. CheckRadioButton( IDC_ITEM_ALL, IDC_ITEM_DEFINE, nCheckID );
  1045. m_editItemBegin.EnableWindow( IDC_ITEM_DEFINE == nCheckID );
  1046. m_editItemEnd.EnableWindow( IDC_ITEM_DEFINE == nCheckID );
  1048. // txt 
  1049. m_btnTxtCheck.SetCheck( m_bTxtCheck );
  1050. m_editTxtDest.EnableWindow( m_bTxtCheck );
  1051. m_btnTxtExplorer.EnableWindow( m_bTxtCheck );
  1052. nCheckID = IDC_EXPORT_OVERWRITE;
  1053. if( !m_bOverwrite )
  1054. nCheckID = IDC_EXPORT_APPEND;
  1055. CheckRadioButton( IDC_EXPORT_OVERWRITE, IDC_EXPORT_APPEND, nCheckID );
  1057. // mdb
  1058. m_btnMdbCheck.SetCheck( m_bMdbCheck );
  1059. m_editMdbDest.EnableWindow( m_bMdbCheck );
  1060. m_btnMdbExplorer.EnableWindow( m_bMdbCheck );
  1062. // Csv
  1063. m_btnCsvCheck.SetCheck( m_bCsvCheck );
  1064. m_editCsvDest.EnableWindow( m_bCsvCheck );
  1065. m_btnCsvExplorer.EnableWindow( m_bCsvCheck );
  1067. // ODBC
  1068. m_btnODBCCheck.SetCheck( m_bODBCCheck );
  1069. m_editODBCDest.EnableWindow( m_bODBCCheck );
  1070. m_btnODBCSource.EnableWindow( m_bODBCCheck );
  1072. // progress ctrl
  1073. m_ctrlProgress.SetWindowPos( NULL, 0, 0, 0, 0, SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE );
  1075. return TRUE;  // return TRUE unless you set the focus to a control
  1076.               // EXCEPTION: OCX Property Pages should return FALSE
  1077. }
  1079. void CListExportDlg::OnItemAll() 
  1080. {
  1081. // TODO: Add your control notification handler code here
  1082. m_editItemBegin.EnableWindow( FALSE );
  1083. m_editItemEnd.EnableWindow( FALSE );
  1084. }
  1086. void CListExportDlg::OnItemSelected() 
  1087. {
  1088. // TODO: Add your control notification handler code here
  1089. m_editItemBegin.EnableWindow( FALSE );
  1090. m_editItemEnd.EnableWindow( FALSE );
  1091. }
  1093. void CListExportDlg::OnItemDefine() 
  1094. {
  1095. // TODO: Add your control notification handler code here
  1096. m_editItemBegin.EnableWindow( TRUE );
  1097. m_editItemEnd.EnableWindow( TRUE );
  1098. }
  1100. void CListExportDlg::OnTxtCheck() 
  1101. {
  1102. // TODO: Add your control notification handler code here
  1103. int nCheck = m_btnTxtCheck.GetCheck();
  1104. m_editTxtDest.EnableWindow( nCheck );
  1105. m_btnTxtExplorer.EnableWindow( nCheck );
  1106. }
  1108. void CListExportDlg::OnTxtExplorer() 
  1109. {
  1110. // TODO: Add your control notification handler code here
  1111. UpdateData( );
  1113. CFileDialog dlg (FALSE, NULL, NULL, OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_ENABLESIZING,
  1114. "Txt files (*.txt)|*.txt|All files (*.*)|*.*||", NULL);
  1115. if( IDOK == dlg.DoModal() )
  1116. {
  1117. m_strTxtDest = dlg.GetPathName();
  1118. UpdateData( FALSE );
  1119. }
  1120. }
  1122. void CListExportDlg::OnMdbCheck() 
  1123. {
  1124. // TODO: Add your control notification handler code here
  1125. int nCheck = m_btnMdbCheck.GetCheck();
  1126. m_editMdbDest.EnableWindow( nCheck );
  1127. m_btnMdbExplorer.EnableWindow( nCheck );
  1128. }
  1130. void CListExportDlg::OnMdbExplorer() 
  1131. {
  1132. // TODO: Add your control notification handler code here
  1133. UpdateData( );
  1135. CFileDialog dlg (FALSE, NULL, NULL, OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_ENABLESIZING,
  1136. "Microsoft Access Database files (*.mdb)|*.mdb|All files (*.*)|*.*||", NULL);
  1137. if( IDOK == dlg.DoModal() )
  1138. {
  1139. m_strMdbDest = dlg.GetPathName();
  1140. UpdateData( FALSE );
  1141. }
  1142. }
  1144. void CListExportDlg::OnCsvCheck() 
  1145. {
  1146. // TODO: Add your control notification handler code here
  1147. int nCheck = m_btnCsvCheck.GetCheck();
  1148. m_editCsvDest.EnableWindow( nCheck );
  1149. m_btnCsvExplorer.EnableWindow( nCheck );
  1150. }
  1152. void CListExportDlg::OnODBCCheck() 
  1153. {
  1154. // TODO: Add your control notification handler code here
  1155. int nCheck = m_btnODBCCheck.GetCheck();
  1156. m_editODBCDest.EnableWindow( nCheck );
  1157. m_btnODBCSource.EnableWindow( nCheck );
  1158. }
  1160. void CListExportDlg::OnCsvExplorer() 
  1161. {
  1162. // TODO: Add your control notification handler code here
  1163. UpdateData( );
  1165. CFileDialog dlg (FALSE, NULL, NULL, OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_ENABLESIZING,
  1166. "CSV files (*.csv)|*.csv|All files (*.*)|*.*||", NULL);
  1167. if( IDOK == dlg.DoModal() )
  1168. {
  1169. m_strCsvDest = dlg.GetPathName();
  1170. UpdateData( FALSE );
  1171. }
  1172. }
  1174. void CListExportDlg::OnOdbcSource() 
  1175. {
  1176. // TODO: Add your control notification handler code here
  1177. UpdateData( TRUE );
  1179. if( m_exportdb.OpenODBCDB( NULL ) )
  1180. {
  1181. m_strODBCDest = m_exportdb.GetODBCConnect();
  1182. UpdateData( FALSE );
  1183. }
  1184. }
  1186. void CListExportDlg::OnOK() 
  1187. {
  1188. // TODO: Add extra validation here
  1189. UpdateData( );
  1191. // if( !AfxAssertFunclimitProf( ) )
  1192. // return;
  1194. CButton * pbtnAll = (CButton *)GetDlgItem( IDC_ITEM_ALL );
  1195. if( pbtnAll ) m_bItemAll = pbtnAll->GetCheck();
  1196. CButton * pbtnSelected = (CButton *)GetDlgItem( IDC_ITEM_SELECTED );
  1197. if( pbtnSelected ) m_bItemSelected = pbtnSelected->GetCheck();
  1198. CButton * pbtnDefine = (CButton *)GetDlgItem( IDC_ITEM_DEFINE );
  1199. if( pbtnDefine ) m_bItemDefine = pbtnDefine->GetCheck();
  1201. if( !m_bItemAll && !m_bItemSelected && !m_bItemDefine )
  1202. m_bItemAll = TRUE;
  1204. CButton * pbtn = (CButton *)GetDlgItem( IDC_EXPORT_OVERWRITE );
  1205. if( pbtn ) m_bOverwrite = pbtn->GetCheck();
  1207. if( !m_bTxtCheck && !m_bMdbCheck && !m_bCsvCheck && !m_bODBCCheck )
  1208. {
  1209. AfxMessageBox( IDS_EXPORTDB_NODEST, MB_OK | MB_ICONINFORMATION );
  1210. return;
  1211. }
  1213. if( m_bTxtCheck && m_strTxtDest.GetLength() == 0 )
  1214. {
  1215. AfxMessageBox( IDS_EXPORTDB_NOTXTDEST, MB_OK | MB_ICONINFORMATION );
  1216. return;
  1217. }
  1218. if( m_bMdbCheck && m_strMdbDest.GetLength() == 0 )
  1219. {
  1220. AfxMessageBox( IDS_EXPORTDB_NOMDBDEST, MB_OK | MB_ICONINFORMATION );
  1221. return;
  1222. }
  1223. if( m_bCsvCheck && m_strCsvDest.GetLength() == 0 )
  1224. {
  1225. AfxMessageBox( IDS_EXPORTDB_NOCSVDEST, MB_OK | MB_ICONINFORMATION );
  1226. return;
  1227. }
  1228. if( m_bODBCCheck && m_strODBCDest.GetLength() == 0 )
  1229. {
  1230. AfxMessageBox( IDS_EXPORTDB_NOODBCDEST, MB_OK | MB_ICONINFORMATION );
  1231. return;
  1232. }
  1234. if( m_bMdbCheck )
  1235. {
  1236. int nIndex = m_strMdbDest.Find( "." );
  1237. if( -1 == nIndex )
  1238. m_strMdbDest += ".mdb";
  1239. else if( m_strMdbDest.GetLength()-1 == nIndex )
  1240. m_strMdbDest += "mdb";
  1241. }
  1242. if( m_bCsvCheck )
  1243. {
  1244. int nIndex = m_strCsvDest.Find( "." );
  1245. if( -1 == nIndex )
  1246. m_strCsvDest += ".csv";
  1247. else if( m_strCsvDest.GetLength()-1 == nIndex )
  1248. m_strCsvDest += "csv";
  1249. }
  1250. UpdateData( FALSE );
  1252. // Store profile
  1253. StoreProfile( );
  1255. // Export
  1256. CSListView * pView = AfxGetSListView( );
  1257. if( pView )
  1258. pView->ExportList( this );
  1259. else
  1260. ExportFinish( );
  1261. }