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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > SQL Server > 查看源码
ResultView.cpp
资源名称：ISQL_src.zip　[点击查看]
上传用户：jsxglz
上传日期：2007-01-03
资源大小：117k
文件大小：14k
源码类别：

SQL Server

开发平台：

Visual C++

ResultView.cpp：源码内容
  1. // ResultView.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. #include "InteractiveSQL.h"
  6. #include "ResultView.h"
  7. #include "InteractiveSQLDoc.h"
  8. #include "resource.h"
  9. #include "MainFrm.h"
  10. #include "SQLView.h"
  11. #include "ExportDlg.h"
  13. #ifdef _DEBUG
  14. #define new DEBUG_NEW
  15. #undef THIS_FILE
  16. static char THIS_FILE[] = __FILE__;
  17. #endif
  19. /////////////////////////////////////////////////////////////////////////////
  20. // CResultView
  22. IMPLEMENT_DYNCREATE(CResultView, CRichEditView)
  24. CResultView::CResultView()
  25. {
  26. m_nWordWrap = WrapNone;
  28. // Edit font
  29. LOGFONT logFont;
  30. memset(&logFont, 0, sizeof(logFont));
  31. logFont.lfHeight = -15;
  32. logFont.lfWeight = 400;
  33. strcpy(logFont.lfFaceName, "Courier");
  35. if(!m_font.CreateFontIndirect(&logFont))
  36. TRACE("Could Not create font.n");
  38. m_pGridCtrl = NULL;
  39. }
  41. CResultView::~CResultView()
  42. {
  43. if(m_font.m_hObject)
  44. {
  45. m_font.Detach();
  46. m_font.m_hObject = NULL;
  47. }
  48. }
  50. BEGIN_MESSAGE_MAP(CResultView, CRichEditView)
  51. //{{AFX_MSG_MAP(CResultView)
  52. ON_WM_SIZE()
  53. ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
  54. ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
  55. ON_WM_CREATE()
  56. ON_UPDATE_COMMAND_UI(ID_FILE_NEW, OnUpdateFileNew)
  57. ON_UPDATE_COMMAND_UI(ID_FILE_OPEN, OnUpdateFileOpen)
  58. ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave)
  59. ON_UPDATE_COMMAND_UI(ID_FILE_SAVE_AS, OnUpdateFileSaveAs)
  60. ON_COMMAND(ID_FILE_PRINT, OnFilePrint)
  61. ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
  62. ON_WM_MOUSEACTIVATE()
  63. ON_UPDATE_COMMAND_UI(ID_FILE_PRINT, OnUpdateFilePrint)
  64. ON_COMMAND(ID_VIEW_WRAP_WORD, OnViewWrapWord)
  65. ON_UPDATE_COMMAND_UI(ID_VIEW_WRAP_WORD, OnUpdateViewWrapWord)
  66. ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
  67. ON_WM_SETFOCUS()
  68. ON_COMMAND(ID_GRID_SAVE_SELECTION, OnGridSaveSelection)
  69. ON_COMMAND(ID_EDIT_SELECT_ALL, OnEditSelectAll)
  70. ON_UPDATE_COMMAND_UI(ID_EDIT_SELECT_ALL, OnUpdateEditSelectAll)
  71. //}}AFX_MSG_MAP
  72. ON_COMMAND(ID_FILE_PRINT, CRichEditView::OnFilePrint)
  73. END_MESSAGE_MAP()
  75. /////////////////////////////////////////////////////////////////////////////
  76. // CResultView diagnostics
  78. #ifdef _DEBUG
  79. void CResultView::AssertValid() const
  80. {
  81. CRichEditView::AssertValid();
  82. }
  84. void CResultView::Dump(CDumpContext& dc) const
  85. {
  86. CRichEditView::Dump(dc);
  87. }
  89. CInteractiveSQLDoc* CResultView::GetDocument() // non-debug version is inline
  90. {
  91. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CInteractiveSQLDoc)));
  92. return (CInteractiveSQLDoc*)m_pDocument;
  93. }
  94. #endif //_DEBUG
  96. /////////////////////////////////////////////////////////////////////////////
  97. // CResultView message handlers
  99. void CResultView::OnSize(UINT nType, int cx, int cy) 
  100. {
  101. CRichEditView::OnSize(nType, cx, cy);
  103. if(m_pGridCtrl && m_pGridCtrl->m_hWnd != NULL)
  104. m_pGridCtrl->MoveWindow(0, 0, cx, cy);
  105. }
  107. void CResultView::OnEditCopy()
  108. {
  109. CWaitCursor wait;
  111. bool bCopyGrid = m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  112. m_pGridCtrl->IsWindowVisible();
  113. if(bCopyGrid)
  114. CopyGridData();
  115. else
  116. GetRichEditCtrl().Copy();
  117. }
  119. void CResultView::CopyGridData()
  120. {
  121. CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
  122. ASSERT(pFrame);
  123. pFrame->m_wndStatusBar.SetPaneText(0, "Copying...");
  125. long lCol = m_pGridCtrl->GetCol();
  126. long lRow = m_pGridCtrl->GetRow();
  127. long lColSel = m_pGridCtrl->GetColSel();
  128. long lRowSel = m_pGridCtrl->GetRowSel();
  129. CSharedFile memFile(GMEM_MOVEABLE | GMEM_DDESHARE | GMEM_ZEROINIT);
  130. CString sBuff;
  131. USES_CONVERSION;
  132. for(long lR = lRow; lR <= lRowSel; lR++)
  133. {
  134. for(long lC = lCol; lC <= lColSel; lC++)
  135. {
  136. sBuff = m_pGridCtrl->GetTextMatrix(lR, lC);
  137. memFile.Write(T2A(const_cast<LPTSTR>((LPCTSTR)sBuff)), sBuff.GetLength());
  138. if(lC < lColSel)
  139. memFile.Write("t", strlen("t"));
  140. }
  141. if(lR < lRowSel)
  142. memFile.Write("n", strlen("n"));
  143. }
  145. COleDataSource* pDataSource = new COleDataSource;
  146. ASSERT(pDataSource);
  147. pDataSource->CacheGlobalData(CF_TEXT, memFile.Detach());
  148. pDataSource->SetClipboard();
  150. pFrame->m_wndStatusBar.SetPaneText(0, "");
  151. }
  153. void CResultView::OnUpdateEditCopy(CCmdUI* pCmdUI) 
  154. {
  155. bool bEnable = (m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  156. m_pGridCtrl->IsWindowVisible()) || GetRichEditCtrl().GetTextLength();
  157. pCmdUI->Enable(bEnable);
  158. }
  160. int CResultView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  161. {
  162. if(CRichEditView::OnCreate(lpCreateStruct) == -1)
  163. return -1;
  165. if(m_font.m_hObject)
  166. GetRichEditCtrl().SetFont(&m_font);
  168. return 0;
  169. }
  171. void CResultView::OnUpdateFileNew(CCmdUI* pCmdUI) 
  172. {
  173. pCmdUI->Enable(FALSE);
  174. }
  176. void CResultView::OnUpdateFileOpen(CCmdUI* pCmdUI) 
  177. {
  178. pCmdUI->Enable(FALSE);
  179. }
  181. void CResultView::OnUpdateFileSave(CCmdUI* pCmdUI) 
  182. {
  183. pCmdUI->Enable(FALSE);
  184. }
  186. void CResultView::OnUpdateFileSaveAs(CCmdUI* pCmdUI) 
  187. {
  188. bool bEnable = (m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  189. m_pGridCtrl->IsWindowVisible());
  190. pCmdUI->Enable(bEnable || GetRichEditCtrl().GetTextLength());
  191. }
  193. void CResultView::OnFilePrint() 
  194. {
  195. CWaitCursor wait;
  197. CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
  198. ASSERT(pFrame);
  199. CDocument* pDoc = pFrame->GetActiveDocument();
  200. ASSERT(pDoc);
  201. CString sTitle = pDoc->GetTitle();
  202. if(sTitle.IsEmpty())
  203. sTitle = "Untitled.";
  204. if(m_strObjName.IsEmpty())
  205. m_strObjName = "Untitled";
  206. pFrame->LockWindowUpdate();
  207. pDoc->SetTitle(m_strObjName);
  208. CRichEditView::OnFilePrint();
  209. pDoc->SetTitle(sTitle);
  210. pFrame->UnlockWindowUpdate();
  211. }
  213. void CResultView::OnGridSaveSelection() 
  214. {
  215. if(!ExportResults(true))
  216. TRACE("Error exporting results.n");
  217. }
  219. void CResultView::OnFileSaveAs() 
  220. {
  221. CWaitCursor wait;
  223. bool bExport = m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  224. m_pGridCtrl->IsWindowVisible();
  226. if(bExport)
  227. {
  228. if(!ExportResults())
  229. TRACE("Error exporting results.n");
  230. }
  231. else
  232. {
  233. CStringEx sBuff;
  234. GetRichEditCtrl().GetWindowText(sBuff);
  235. CString strFilter, sDefaultExt;
  236. if(!m_strObjName.IsEmpty() && sBuff.FindNoCase(m_strObjName) != -1)
  237. {
  238. sDefaultExt = _T("sql");
  239. strFilter = _T("Procedure Files (*.sql)|*.sql|All Files (*.*)|*.*|");
  240. }
  241. else
  242. {
  243. sDefaultExt = _T("txt");
  244. strFilter = _T("Text Files (*.txt)|*.txt|All Files(*.*)|*.*|");
  245. m_strObjName = _T("Untitled"); // Emptied in <CMainFrame::OnExceptionClear>
  246. }
  247.     
  248. CFileDialog dlg(false, sDefaultExt, m_strObjName, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
  249. strFilter, this);
  250. if(dlg.DoModal() == IDOK)
  251. {
  252. CWaitCursor wait;
  254. CString sBuff;
  255. CString sPathName = dlg.GetPathName();
  257. CStdioFile file;
  258. CFileException fileException;
  259. if(!file.Open(sPathName, CFile::typeText | CFile::modeCreate |  
  260. CFile::modeWrite, &fileException))
  261. {
  262. sBuff.Format("File Path Name: <%s> ", sPathName);
  263. sBuff += CHelpers::GetFileExceptionError(fileException.m_cause);
  264. AfxMessageBox(sBuff);
  265. }
  266. else
  267. {
  268. GetRichEditCtrl().GetWindowText(sBuff);
  269. file.WriteString(sBuff);
  270. }
  271. }
  272. }
  273. }
  275. int CResultView::OnMouseActivate(CWnd* pDesktopWnd, UINT nHitTest, UINT message) 
  276. {
  277. const MSG* pMsg = GetCurrentMessage();
  278. GetParent()->SendMessage(WM_MOUSEACTIVATE, pMsg->wParam, pMsg->lParam);
  280. return CRichEditView::OnMouseActivate(pDesktopWnd, nHitTest, message);
  281. }
  283. HMENU CResultView::GetContextMenu(WORD /*wSelType*/, LPOLEOBJECT /*lpOleObj*/,
  284.    CHARRANGE* /*lpChrg*/)
  285. { 
  286. bool bOkToInvokeGridMenu = m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  287. m_pGridCtrl->IsWindowVisible();
  288. if(bOkToInvokeGridMenu)
  289. InvokeGridMenu();
  290. else
  291. {
  292. CMenu menu;
  293. if(menu.LoadMenu(IDR_RCLICK))
  294. {
  295. CMenu* pMenu = menu.GetSubMenu(2);
  296. ASSERT(pMenu);
  297. int nTextLength = GetRichEditCtrl().GetTextLength();
  298. if(!nTextLength)
  299. {
  300. pMenu->EnableMenuItem(ID_EDIT_SELECT_ALL, MF_BYCOMMAND | MF_GRAYED);
  301. pMenu->EnableMenuItem(ID_FILE_SAVE_AS, MF_BYCOMMAND | MF_GRAYED);
  302. pMenu->EnableMenuItem(ID_FILE_PRINT, MF_BYCOMMAND | MF_GRAYED);
  303. pMenu->EnableMenuItem(ID_EDIT_CLEAR, MF_BYCOMMAND | MF_GRAYED);
  304. }
  306. if(GetRichEditCtrl().GetSelText().IsEmpty())
  307. {
  308. pMenu->EnableMenuItem(ID_EDIT_CUT, MF_BYCOMMAND | MF_GRAYED);
  309. pMenu->EnableMenuItem(ID_EDIT_COPY, MF_BYCOMMAND | MF_GRAYED);
  310. }
  312. if(!GetRichEditCtrl().CanPaste())
  313. pMenu->EnableMenuItem(ID_EDIT_PASTE, MF_BYCOMMAND | MF_GRAYED);
  315. if(!GetRichEditCtrl().CanUndo())
  316. pMenu->EnableMenuItem(ID_EDIT_UNDO, MF_BYCOMMAND | MF_GRAYED);
  318. CPoint point;
  319. ::GetCursorPos(&point);
  320. pMenu->TrackPopupMenu(0, point.x, point.y, this);
  321. }
  322. }
  324. return NULL;
  325. }
  327. void CResultView::OnUpdateFilePrint(CCmdUI* pCmdUI) 
  328. {
  329. pCmdUI->Enable(GetRichEditCtrl().GetTextLength());
  330. }
  332. void CResultView::OnViewWrapWord() 
  333. {
  334. m_nWordWrap = (m_nWordWrap == WrapNone) ? WrapToWindow : WrapNone;
  335. WrapChanged();
  336. }
  338. void CResultView::OnUpdateViewWrapWord(CCmdUI* pCmdUI) 
  339. {
  340. pCmdUI->Enable(GetRichEditCtrl().GetTextLength());
  341. pCmdUI->SetCheck(m_nWordWrap == WrapToWindow);
  342. }
  344. void CResultView::SetWrapNone()
  345. {
  346. if(m_nWordWrap == WrapToWindow)
  347. {
  348. m_nWordWrap = WrapNone;
  349. WrapChanged();
  350. }
  351. }
  353. void CResultView::SetWrapToWindow()
  354. {
  355. if(m_nWordWrap == WrapNone)
  356. {
  357. m_nWordWrap = WrapToWindow;
  358. WrapChanged();
  359. }
  360. }
  362. void CResultView::OnUpdateEditPaste(CCmdUI* pCmdUI) 
  363. {
  364. bool bEnable = m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  365. m_pGridCtrl->IsWindowVisible();
  366. pCmdUI->Enable(!bEnable);
  367. }
  369. void CResultView::OnSetFocus(CWnd* pOldWnd) 
  370. {
  371. bool bFocus = m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  372. m_pGridCtrl->IsWindowVisible();
  373. if(bFocus)
  374. m_pGridCtrl->SetFocus();
  375. else
  376. CRichEditView::OnSetFocus(pOldWnd);
  377. }
  379. BOOL CResultView::ExportResults(const bool& bSaveSelection)
  380. {
  381. CWaitCursor wait;
  383. BOOL bRet = FALSE;
  385. CString strFilter = _T("Export Files (*.csv)|*.csv|All Files(*.*)|*.*|");
  386. CExportDlg dlg(false, _T("csv"), "Untitled", OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
  387. strFilter, this);
  388. dlg.m_bSaveSelection = bSaveSelection;
  389. if(bSaveSelection)
  390. dlg.m_ofn.lpstrTitle = "Save Selection";
  391. else
  392. dlg.m_ofn.lpstrTitle = "Save Grid Results";
  393. if(dlg.DoModal() != IDOK)
  394. return FALSE;
  396. CString sBuff;
  397. CString sPathName = dlg.GetPathName();
  398. CStdioFile file;
  399. CFileException fileException;
  400. bRet = file.Open(sPathName, CFile::typeText | CFile::modeCreate |  
  401. CFile::modeWrite, &fileException);
  402. if(!bRet)
  403. {
  404. sBuff.Format("File Path Name: <%s> ", sPathName);
  405. sBuff += CHelpers::GetFileExceptionError(fileException.m_cause);
  406. AfxMessageBox(sBuff);
  407. }
  408. else
  409. {
  410. if(!ExportToFile(&file, dlg.m_strDelimiter, dlg.m_bColumnNames, bSaveSelection))
  411. {
  412. TRACE("Error exporting to file.n");
  413. file.Close();
  414. file.Remove(sPathName);
  415. bRet = FALSE;
  416. }
  417. }
  419. return bRet;
  420. }
  422. void CResultView::InvokeGridMenu()
  423. {
  424. CWaitCursor wait;
  426. CMenu menu;
  427. if(menu.LoadMenu(IDR_RCLICK))
  428. {
  429. CMenu* pMenu = menu.GetSubMenu(1);
  430. if(pMenu)
  431. {
  432. CPoint point;
  433. ::GetCursorPos(&point);
  434. pMenu->TrackPopupMenu(0, point.x, point.y, this);
  435. }
  436. }
  437. }
  439. BOOL CResultView::ExportToFile(CStdioFile* pFile, LPCTSTR lpszDelimiter,
  440. const BOOL& bColumnNames, const bool& bSaveSelection)
  441. {
  442. CWaitCursor wait;
  444. CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
  445. ASSERT(pFrame);
  447. BOOL bRet = TRUE;
  449. ASSERT(pFile && pFile->m_pStream);
  451. if(bSaveSelection)
  452. {
  453. pFrame->m_wndStatusBar.SetPaneText(0, "Saving selection...");
  455. long lCol = m_pGridCtrl->GetCol();
  456. long lRow = m_pGridCtrl->GetRow();
  457. long lColSel = m_pGridCtrl->GetColSel();
  458. long lRowSel = m_pGridCtrl->GetRowSel();
  459. for(long lR = lRow; lR <= lRowSel; lR++)
  460. {
  461. for(long lC = lCol; lC <= lColSel; lC++)
  462. {
  463. pFile->WriteString(m_pGridCtrl->GetTextMatrix(lR, lC));
  464. if(lC < lColSel)
  465. pFile->WriteString(lpszDelimiter);
  466. }
  467. if(lR < lRowSel)
  468. pFile->WriteString("n");
  469. }
  470. }
  471. else
  472. {
  473. pFrame->m_wndStatusBar.SetPaneText(0, "Saving grid results...");
  475. CMSFlexGrid* pGrid = NULL;
  476. long lCols = 0;
  477. long lRows = 0;
  478. for(POSITION pos = pFrame->m_GridList.GetHeadPosition(); pos != NULL;)
  479. {
  480. pGrid = (CMSFlexGrid*)pFrame->m_GridList.GetNext(pos);
  481. ASSERT(pGrid);
  482. lCols = pGrid->GetCols();
  483. lRows = pGrid->GetRows();
  484. for(long lR = (bColumnNames ? 0 : 1); lR < lRows; lR++)
  485. {
  486. for(long lC = 0; lC < lCols; lC++)
  487. {
  488. pFile->WriteString(pGrid->GetTextMatrix(lR, lC));
  489. if(lC < lCols-1)
  490. pFile->WriteString(lpszDelimiter);
  491. }
  492. if(lR < lRows)
  493. pFile->WriteString("n");
  494. }
  496. pFile->WriteString("n");
  497. }
  498. }
  500. pFile->Close();
  502. pFrame->m_wndStatusBar.SetPaneText(0, "");
  504. return bRet;
  505. }
  507. void CResultView::OnInitialUpdate() 
  508. {
  509. CRichEditView::OnInitialUpdate();
  511. SetMargins(CRect(720, 720, 720, 720));
  512. }
  514. BOOL CResultView::OnPreparePrinting(CPrintInfo* pInfo) 
  515. {
  516. return DoPreparePrinting(pInfo);
  517. }
  519. BOOL CResultView::PreTranslateMessage(MSG* pMsg) 
  520. {
  521. if(m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  522. m_pGridCtrl->IsWindowVisible())
  523. {
  524. if(pMsg->message == WM_KEYDOWN)
  525. {
  526. if(pMsg->wParam != VK_RETURN)
  527. return m_pGridCtrl->PreTranslateMessage(pMsg);
  528. else
  529. {
  530. ::MessageBeep(MB_ICONEXCLAMATION);
  531. return TRUE;
  532. }
  533. }
  534. }
  536. return CRichEditView::PreTranslateMessage(pMsg);
  537. }
  539. void CResultView::OnEditSelectAll() 
  540. {
  541. bool bGridSelectAll = m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  542. m_pGridCtrl->IsWindowVisible();
  543. if(!bGridSelectAll)
  544. GetRichEditCtrl().SetSel(0, GetRichEditCtrl().GetTextLength());
  545. else
  546. {
  547. m_pGridCtrl->SetRow(1);
  548. m_pGridCtrl->SetCol(0);
  549. m_pGridCtrl->SetRowSel(m_pGridCtrl->GetRows()-1);
  550. m_pGridCtrl->SetColSel(m_pGridCtrl->GetCols()-1);
  551. }
  552. }
  554. void CResultView::OnUpdateEditSelectAll(CCmdUI* pCmdUI) 
  555. {
  556. bool bEnable = (m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
  557. m_pGridCtrl->IsWindowVisible() && m_pGridCtrl->GetRows() > 1) ||
  558. GetRichEditCtrl().GetTextLength();
  559. pCmdUI->Enable(bEnable);
  560. }