resultview.cpp

快速SQL交互工具

{
	CWaitCursor wait;

	BOOL bRet = FALSE;

	CString strFilter = _T("Export Files (*.csv)|*.csv|All Files(*.*)|*.*|");
	CExportDlg dlg(false, _T("csv"), _T("Untitled"), OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
				strFilter, this);
	dlg.m_bSaveSelection = bSaveSelection;
	if(bSaveSelection)
		dlg.m_ofn.lpstrTitle = _T("Save Selection");
	else
		dlg.m_ofn.lpstrTitle = _T("Save Grid Results");
	if(dlg.DoModal() != IDOK)
		return FALSE;	

	CString sBuff;
	CString sPathName = dlg.GetPathName();
	CStdioFile file;
	CFileException fileException;
	bRet = file.Open(sPathName, CFile::typeText | CFile::modeCreate |  
				CFile::modeWrite, &fileException);
	if(!bRet)
	{
		sBuff.Format(_T("File Path Name: <%s> "), sPathName);
		sBuff += CHelpers::GetFileExceptionError(fileException.m_cause);
		AfxMessageBox(sBuff);
	}
	else
	{
		if(!ExportToFile(&file, dlg.m_strDelimiter, dlg.m_bColumnNames, bSaveSelection))
		{
			TRACE(_T("Error exporting to file.\n"));
			file.Close();
			file.Remove(sPathName);
			bRet = FALSE;
		}
	}

	return bRet;
}

void CResultView::InvokeGridMenu()
{
	CWaitCursor wait;

	CMenu menu;
	if(menu.LoadMenu(IDR_RCLICK))
	{
		CMenu* pMenu = menu.GetSubMenu(1);
		if(pMenu)
		{
			CPoint point;
			::GetCursorPos(&point);
			pMenu->TrackPopupMenu(0, point.x, point.y, this);
		}
	}
}

BOOL CResultView::ExportToFile(CStdioFile* pFile, LPCTSTR lpszDelimiter,
	const BOOL& bColumnNames, const bool& bSaveSelection)
{
	CWaitCursor wait;

	BOOL bRet = TRUE;

	ASSERT(pFile && pFile->m_pStream);

	if(bSaveSelection)
	{
		m_pChildFrame->m_wndStatusBar.SetPaneText(0, _T("Saving selection..."));

		long lCol = m_pGridCtrl->GetCol();
		long lRow = m_pGridCtrl->GetRow();
		long lColSel = m_pGridCtrl->GetColSel();
		long lRowSel = m_pGridCtrl->GetRowSel();
		if(lColSel < lCol)
		{
			lCol = lColSel;
			lColSel = m_pGridCtrl->GetCol();
		}
		if(lRowSel < lRow)
		{
			lRow = lRowSel;
			lRowSel = m_pGridCtrl->GetRow();
		}
		for(long lR = lRow; lR <= lRowSel; lR++)
		{
			for(long lC = lCol; lC <= lColSel; lC++)
			{
				pFile->WriteString(m_pGridCtrl->GetTextMatrix(lR, lC));
				if(lC < lColSel)
					pFile->WriteString(lpszDelimiter);
			}
			if(lR < lRowSel)
				pFile->WriteString(_T("\n"));
		}
	}
	else
	{
		m_pChildFrame->m_wndStatusBar.SetPaneText(0, _T("Saving grid results..."));

		CMSFlexGrid* pGrid = NULL;
		long lCols = 0;
		long lRows = 0;
		for(POSITION pos = m_pChildFrame->m_GridList.GetHeadPosition(); pos != NULL;)
		{
			pGrid = (CMSFlexGrid*)m_pChildFrame->m_GridList.GetNext(pos);
			ASSERT(pGrid);
			lCols = pGrid->GetCols();
			lRows = pGrid->GetRows();
			for(long lR = (bColumnNames ? 0 : 1); lR < lRows; lR++)
			{
				for(long lC = 0; lC < lCols; lC++)
				{
					pFile->WriteString(pGrid->GetTextMatrix(lR, lC));
					if(lC < lCols-1)
						pFile->WriteString(lpszDelimiter);
				}
				if(lR < lRows)
					pFile->WriteString(_T("\n"));
			}

			pFile->WriteString(_T("\n"));
		}
	}
	
	pFile->Close();

	return bRet;
}

void CResultView::OnInitialUpdate() 
{
	CRichEditView::OnInitialUpdate();

	SetMargins(CRect(720, 720, 720, 720));
}

BOOL CResultView::OnPreparePrinting(CPrintInfo* pInfo) 
{
	BOOL bRet = DoPreparePrinting(pInfo);

	if(pInfo->m_pPD->GetDevMode()->dmOrientation == DMORIENT_LANDSCAPE)
	{
		CString sMsg = "Currently printing functionality is not supported for ";
				sMsg +="landscape mode. Please choose portrait mode and then try ";
				sMsg +="again.";
		AfxMessageBox(sMsg);
		bRet = FALSE;
	}
		
	return bRet;
}

BOOL CResultView::PreTranslateMessage(MSG* pMsg) 
{
	if(m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
		m_pGridCtrl->IsWindowVisible())
	{
		if(pMsg->message == WM_KEYDOWN)
		{
			if(pMsg->wParam == VK_RETURN)
				::MessageBeep(MB_ICONEXCLAMATION);
			else
				PreTranslateInput(pMsg);
		}
	}
	
	return CRichEditView::PreTranslateMessage(pMsg);
}

void CResultView::OnEditSelectAll() 
{
	bool bGridSelectAll = m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
				m_pGridCtrl->IsWindowVisible();
	if(!bGridSelectAll)
		GetRichEditCtrl().SetSel(0, -1);
	else
	{
		m_pGridCtrl->SetRow(1);
		m_pGridCtrl->SetCol(0);
		m_pGridCtrl->SetRowSel(m_pGridCtrl->GetRows()-1);
		m_pGridCtrl->SetColSel(m_pGridCtrl->GetCols()-1);
	}
}

void CResultView::OnUpdateEditSelectAll(CCmdUI* pCmdUI) 
{
	bool bEnable = (m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
		m_pGridCtrl->IsWindowVisible() && m_pGridCtrl->GetRows() > 1) ||
		GetRichEditCtrl().GetTextLength();
	pCmdUI->Enable(bEnable);	
}

void CResultView::OnViewFont() 
{
	bool bGridFont = m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
			m_pGridCtrl->IsWindowVisible();
	if(!bGridFont)
		SetResultViewFont();
	else
	{
		try
		{
			if(m_pChildFrame->m_bExecuting)
			{
				m_pGridCtrl->Invalidate();
				m_pGridCtrl->UpdateWindow();
			}
			
			SetGridFont();

			if(m_pChildFrame->m_bExecuting)
			{
				m_pGridCtrl->Invalidate();
				m_pGridCtrl->UpdateWindow();
			}
		}
		catch(COleDispatchException* e)
		{
			if(e)
			{
				AfxMessageBox(e->m_strDescription);
				e->Delete();
			}
		}
		catch(...)
		{
			AfxMessageBox(_T("Errors occurred."));
		}
	}
}

void CResultView::SetGridFont()
{
	COleFont font(m_pGridCtrl->GetFont());
	LOGFONT lf;
	memset(&lf, 0, sizeof(lf));
	lf.lfCharSet = font.GetCharset();
	lf.lfItalic = font.GetItalic();
	lstrcpyn((TCHAR*)lf.lfFaceName, font.GetName(), sizeof(lf.lfFaceName));
	lf.lfStrikeOut = font.GetStrikethrough();
	lf.lfUnderline = font.GetUnderline();
	lf.lfWeight = font.GetWeight();
	CDC dc;
	dc.Attach(::GetDC(NULL));
	CY cy = font.GetSize();
	lf.lfHeight = MulDiv(cy.Lo/10000, dc.GetDeviceCaps(LOGPIXELSY), 72);
	::ReleaseDC(NULL, dc.Detach());
 	CFontDialog dlg(&lf, CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT);
	if(dlg.DoModal() == IDOK)
	{
		CWaitCursor wait;
		CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
		ASSERT(pFrame != NULL);
		CChildFrame* pChild = NULL;
		std::list<CChildFrame*>::const_iterator i;
		int nGridCount = -1;
		CMSFlexGrid* pGrid = NULL;
		for(i = pFrame->m_listChildFrame.begin();
			i != pFrame->m_listChildFrame.end(); ++i)
		{
			pChild = (*i);
			if(pChild != NULL)
			{
				pChild->m_GridFont.m_lf = *dlg.m_cf.lpLogFont;
				pChild->m_GridFont.m_bIsBold = dlg.IsBold();
				pChild->m_GridFont.m_strFaceName = dlg.GetFaceName();
				pChild->m_GridFont.m_bIsBold = dlg.IsBold();
				pChild->m_GridFont.m_nSize = dlg.GetSize()*1000;

				for(int n = 0; n < pChild->m_nGridCount; n++)
				{
					pGrid = (CMSFlexGrid*)pChild->m_GridList.GetAt(
						pChild->m_GridList.FindIndex(n));
					if(pGrid != NULL)
					{
						font = pGrid->GetFont();
						font.SetBold(dlg.IsBold());
						font.SetCharset(dlg.m_cf.lpLogFont->lfCharSet);
						font.SetItalic(dlg.m_cf.lpLogFont->lfItalic);
						font.SetName(dlg.GetFaceName());
						cy.Lo = dlg.GetSize()*1000;
						cy.Hi = 0;
						cy.int64 = cy.Lo;
						font.SetSize(cy);
						font.SetUnderline(dlg.m_cf.lpLogFont->lfUnderline);
						font.SetWeight(dlg.m_cf.lpLogFont->lfWeight);
					}
				}
			}
		}
		
		if(pChild != NULL)
			pChild->WriteProfileFont(
				g_szGridFont,
				&pChild->m_GridFont.m_lf,
				true,
				&pChild->m_GridFont.m_bIsBold,
				&pChild->m_GridFont.m_nSize
				);
	}
}

void CResultView::SetResultViewFont()
{
	LOGFONT lf;
	if(m_font.m_hObject != NULL)
		m_font.GetObject(sizeof(LOGFONT), &lf);
	else
		::GetObject(GetStockObject(SYSTEM_FONT), sizeof(LOGFONT), &lf);
	CFontDialog dlg(&lf, CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT);
	if(dlg.DoModal() == IDOK)
	{
		CWaitCursor wait;
		CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd();
		ASSERT(pFrame != NULL);
		CChildFrame* pChild = NULL;
		std::list<CChildFrame*>::const_iterator i;
		long nStart = -1;
		long nEnd = -1;
		for(i = pFrame->m_listChildFrame.begin();
				i != pFrame->m_listChildFrame.end(); ++i)
		{
			pChild = (*i);
			if(pChild != NULL)
			{
				if(pChild->m_pResultView->m_font.m_hObject != NULL)
					pChild->m_pResultView->m_font.DeleteObject();
				if(pChild->m_pResultView->m_font.CreateFontIndirect(&lf))
					pChild->m_pResultView->SetFontEx();
			}
		}
		
		if(pChild != NULL)
			pChild->WriteProfileFont(
				g_szResultFont,
				dlg.m_cf.lpLogFont,
				false,
				NULL,
				NULL
				);
	}
}

void CResultView::SetFontEx()
{
	long nStart = -1;
	long nEnd = -1;
	CRichEditCtrl& edit = GetRichEditCtrl();
	edit.GetSel(nStart, nEnd);
	edit.SetSel(0, 0);
	edit.SetFont(&m_font, TRUE);
	edit.SetSel(nStart, nEnd);
	edit.Invalidate();
	edit.UpdateWindow();
}

void CResultView::OnEditClearAll() 
{
	CString sMsg = "The requested operation cannot be undone. Are you sure you wish to continue?";
	if(AfxMessageBox(sMsg, MB_YESNO | MB_ICONQUESTION) == IDYES)
	{
		bool bGridClear = (m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
				m_pGridCtrl->IsWindowVisible());
		if(!bGridClear)
		{	
			if(!m_pChildFrame->m_strStatusText.CompareNoCase(g_szMessages))
				m_pChildFrame->m_strMessages.erase();
			else
			{
				if(m_pChildFrame->m_strProcText.length())
					m_pChildFrame->m_strProcText.erase();
			}
			GetRichEditCtrl().SetWindowText(NULL);
			Invalidate();
			UpdateWindow();
		}
		else
		{
			m_pChildFrame->m_pQryView->SetFocus();
			m_pChildFrame->OnExceptionClear("");
			SetFocus();
		}

		m_pChildFrame->OnViewMessages();

		if(!m_pChildFrame->m_strMessages.length() && !m_pChildFrame->m_nGridCount &&
			!m_pChildFrame->m_strProcText.length())
		{
			m_pChildFrame->m_strPaneTextZero = "Ready";
			m_pChildFrame->m_wndStatusBar.SetPaneText(0, m_pChildFrame->m_strPaneTextZero);
			
			m_pChildFrame->m_strExecutionTime = "Exec time: 00:00:00";
			m_pChildFrame->m_wndStatusBar.SetPaneText(
				m_pChildFrame->m_nExecutionTimePaneNo, m_pChildFrame->m_strExecutionTime
				);
			
			try
			{
				if(m_pChildFrame->m_database.IsOpen())
					m_pChildFrame->m_strStatusText = "CDatabase::IsOpen == TRUE";
				else
					m_pChildFrame->m_strStatusText = "CDatabase::IsOpen == FALSE";
				m_pChildFrame->m_wndStatusBar.SetPaneText(
					2, m_pChildFrame->m_strStatusText
					);
			}
			catch(...)
			{
				m_pChildFrame->m_strStatusText = "Results grid #0 of 0; 0 row(s); 0 col(s)";
				m_pChildFrame->m_wndStatusBar.SetPaneText(
					2, m_pChildFrame->m_strStatusText
					);
			}
		}
	}
}

void CResultView::OnUpdateEditClearAll(CCmdUI* pCmdUI) 
{
	bool bEnable = (m_pGridCtrl && ::IsWindow(m_pGridCtrl->m_hWnd) &&
		m_pGridCtrl->IsWindowVisible());
	pCmdUI->Enable((bEnable || GetRichEditCtrl().GetTextLength()) &&
		!m_pChildFrame->m_bExecuting);		
}