www.pudn.com > 组态软件的语音处理.rar > wavsvw.cpp

// wavsvw.cpp : implementation of the CWaveSampleView class 
// 
 
#include "stdafx.h" 
#include "waves.h" 
#include "wave.h" 
#include "wavesdoc.h" 
#include "wavsvw.h" 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char BASED_CODE THIS_FILE[] = __FILE__; 
#endif 
 
///////////////////////////////////////////////////////////////////////////// 
// CWaveSampleView 
 
IMPLEMENT_DYNCREATE(CWaveSampleView, CView) 
 
BEGIN_MESSAGE_MAP(CWaveSampleView, CView) 
    //{{AFX_MSG_MAP(CWaveSampleView) 
    ON_COMMAND(ID_FILE_SAVE, OnFileSave) 
    ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs) 
    ON_COMMAND(ID_FILE_PLAY, OnFilePlay) 
    ON_COMMAND(ID_FILE_STOP, OnFileStop) 
    ON_WM_LBUTTONDBLCLK() 
    ON_WM_HSCROLL() 
    ON_WM_KEYDOWN() 
    ON_WM_ERASEBKGND() 
    //}}AFX_MSG_MAP 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CWaveSampleView construction/destruction 
 
CWaveSampleView::CWaveSampleView() 
{ 
    m_iWndSamples = 0; 
    m_iFirstSample = 0; 
    m_iNumSamples = 0; 
} 
 
CWaveSampleView::~CWaveSampleView() 
{ 
} 
 
BOOL CWaveSampleView::PreCreateWindow(CREATESTRUCT& cs) 
{ 
    cs.style |= WS_HSCROLL; 
    return CView::PreCreateWindow(cs); 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CWaveSampleView drawing 
 
void CWaveSampleView::OnInitialUpdate() 
{ 
    CWavesDoc* pDoc = GetDocument(); 
    CWave* pWave = pDoc->GetWave(); 
    m_iNumSamples = pWave->GetNumSamples(); 
    SetScrollRange(SB_HORZ, 0, 1000); 
} 
 
 
void CWaveSampleView::OnDraw(CDC* pDC) 
{ 
    CWavesDoc* pDoc = GetDocument(); 
    CWave* pWave = pDoc->GetWave(); 
    CRect rcWnd; 
    GetClientRect(&rcWnd); 
    m_iWndSamples = rcWnd.right; // 1 pixel per sample 
 
    // Create an off-screen buffer so we can update without flicker. 
    CDC dcMem; 
    dcMem.CreateCompatibleDC(pDC); 
    CBitmap bmMem; 
    bmMem.CreateCompatibleBitmap(pDC, rcWnd.right, rcWnd.bottom); 
    CBitmap* pbmMemOld = dcMem.SelectObject(&bmMem); 
    CBrush brBk; 
    brBk.CreateSolidBrush(GetSysColor(COLOR_WINDOW)); 
    dcMem.FillRect(&rcWnd, &brBk); 
 
    // Draw the axis. 
    dcMem.MoveTo(0, rcWnd.bottom / 2); 
    dcMem.LineTo(rcWnd.right, rcWnd.bottom / 2); 
 
    // Draw the samples. 
    CPen penRed (PS_SOLID, 1, RGB(255,0,0)); 
    CPen* ppenOld = dcMem.SelectObject(&penRed); 
    int iMax = min(m_iWndSamples, pWave->GetNumSamples() - m_iFirstSample); 
    int iYPrev = -1; 
    for (int i = 0; i < iMax; i++) { 
        int iSample = pWave->GetSample(i+m_iFirstSample); 
        int y = rcWnd.bottom / 2 - (iSample * (rcWnd.bottom / 2) / 32768); 
        if (iYPrev != -1) { 
            dcMem.MoveTo(i-1, iYPrev); 
            dcMem.LineTo(i, y); 
        } 
        iYPrev = y;  
    } 
    dcMem.SelectObject(ppenOld); 
 
    // Update the screen. 
    pDC->BitBlt(rcWnd.left, rcWnd.top, 
                rcWnd.right - rcWnd.left, rcWnd.bottom - rcWnd.top, 
                &dcMem, 
                0, 0, 
                SRCCOPY); 
 
    // Tidy up. 
    dcMem.SelectObject(pbmMemOld); 
} 
 
 
 
///////////////////////////////////////////////////////////////////////////// 
// CWaveSampleView diagnostics 
 
#ifdef _DEBUG 
void CWaveSampleView::AssertValid() const 
{ 
    CView::AssertValid(); 
} 
 
void CWaveSampleView::Dump(CDumpContext& dc) const 
{ 
    CView::Dump(dc); 
} 
 
CWavesDoc* CWaveSampleView::GetDocument() // Non-debug version is inline 
{ 
    ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CWavesDoc))); 
    return (CWavesDoc*) m_pDocument; 
} 
 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CWaveSampleView message handlers 
 
void CWaveSampleView::OnFileSave() 
{ 
    AfxMessageBox("Not implemented"); 
} 
 
void CWaveSampleView::OnFileSaveAs() 
{ 
    AfxMessageBox("Not implemented"); 
} 
 
void CWaveSampleView::OnFilePlay() 
{ 
    CWavesDoc* pDoc = GetDocument(); 
    CWave* pWave = pDoc->GetWave(); 
    ASSERT(pWave); 
    if (!pWave->Play()) { 
        AfxMessageBox("Failed to play"); 
    } 
} 
 
void CWaveSampleView::OnFileStop() 
{ 
    CWavesDoc* pDoc = GetDocument(); 
    CWave* pWave = pDoc->GetWave(); 
    ASSERT(pWave); 
    pWave->Stop(); 
} 
 
void CWaveSampleView::OnLButtonDblClk(UINT nFlags, CPoint point) 
{ 
    OnFilePlay(); 
} 
 
// TODO: scroll the DC for speed later. 
void CWaveSampleView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
{ 
    switch (nSBCode) { 
    case SB_LEFT: 
        m_iFirstSample = 0; 
        break; 
     
    case SB_RIGHT: 
        m_iFirstSample = m_iNumSamples - m_iWndSamples; 
        break; 
     
    case SB_LINELEFT: 
        m_iFirstSample -= 10; 
        break; 
         
    case SB_PAGELEFT:     
        m_iFirstSample -= m_iWndSamples; 
        break; 
 
    case SB_LINERIGHT: 
        m_iFirstSample += 10; 
        break; 
 
    case SB_PAGERIGHT: 
        m_iFirstSample += m_iWndSamples; 
        break; 
     
    case SB_THUMBPOSITION: 
    case SB_THUMBTRACK: 
        m_iFirstSample = nPos  
                     * (m_iNumSamples - m_iWndSamples) 
                     / 1000; 
        break; 
 
    default: 
        return; 
    } 
 
    if (m_iFirstSample < 0) m_iFirstSample = 0; 
    if (m_iWndSamples >= m_iNumSamples) { 
        m_iFirstSample = 0; 
    } else if (m_iFirstSample >= m_iNumSamples - m_iWndSamples) { 
        m_iFirstSample = m_iNumSamples - m_iWndSamples; 
    } 
 
    int iPos; 
    if (m_iWndSamples >= m_iNumSamples) { 
        iPos = 0; 
    } else { 
        iPos = (1000 * m_iFirstSample) 
             / (m_iNumSamples - m_iWndSamples); 
    } 
    SetScrollPos(SB_HORZ, iPos, TRUE); 
    Invalidate(TRUE); 
} 
 
void CWaveSampleView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{ 
    switch (nChar) { 
    case VK_HOME: 
        OnHScroll(SB_LEFT, 0, NULL); 
        break; 
 
    case VK_END: 
        OnHScroll(SB_RIGHT, 0, NULL); 
        break; 
 
    case VK_LEFT: 
        OnHScroll(SB_LINELEFT, 0, NULL); 
        break; 
 
    case VK_RIGHT: 
        OnHScroll(SB_LINERIGHT, 0, NULL); 
        break; 
 
    case VK_PRIOR: 
        OnHScroll(SB_PAGELEFT, 0, NULL); 
        break; 
 
    case VK_NEXT: 
        OnHScroll(SB_PAGERIGHT, 0, NULL); 
        break; 
     
    default:     
        CView::OnKeyDown(nChar, nRepCnt, nFlags); 
        break; 
    } 
} 
 
// Stub out WM_ERASEBKGND handler so it won't do anything. 
BOOL CWaveSampleView::OnEraseBkgnd(CDC* pDC) 
{ 
    return TRUE; 
}