neuromanager/neuromanager/DataView.cpp

/* --------------------------------------------------------------------- */
/* NeuroManager - A spike train analysis tool                            */
/* Copyright (c) 2005-2006 RIKEN, Japan. All rights reserved.            */
/* http://satellite.sourceforge.jp/                                      */
/* --------------------------------------------------------------------- */
/* This program is free software; you can redistribute it and/or         */
/* modify it under the terms of the GNU General Public License           */
/* as published by the Free Software Foundation; either version 2        */
/* of the License, or (at your option) any later version.                */
/*                                                                       */
/* This program is distributed in the hope that it will be useful,       */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of        */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         */
/* GNU General Public License for more details.                          */
/*                                                                       */
/* You should have received a copy of the GNU General Public License     */
/* along with this program; see the file COPYING.txt. If not, write      */
/* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth      */
/* Floor, Boston, MA 02110-1301, USA.                                    */
/* --------------------------------------------------------------------- */

/* $Id: DataView.cpp,v 1.45 2006/01/24 01:59:57 orrisroot Exp $ */

// DataView.cpp : implementation of the CDataView class
//

#include "stdafx.h"
#include "NeuroManager.h"

#include "NeuroManagerDoc.h"

// #include "backup\MessageToString.h"

#include "DataViewSplitter.h"
#include "DataViewContext.h"
#include "DataViewProperties.h"
#include "DataView.h"
#include ".\dataview.h"

#include <math.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

// CDataView

IMPLEMENT_DYNCREATE( CDataView, CScrollView )

#define DATAVIEW_MUTEX  "CDataView_Mutex"

#define MAX_SCROLLBAR_SIZE 32768   // range : 0~32767

#define DEFAULT_MAGNIFICATION pow(2.0, -3);
#define MAX_MAGNIFICATION  pow(2.0,10)   // 2^10
#define MIN_MAGNIFICATION  pow(2.0,-10)  // 2^-10

// CDataView construction/destruction
CDataView::CDataView()
{
        // create mutex
        m_pMutex = new CMutex( FALSE, DATAVIEW_MUTEX );

        // constant value
        m_uixPad = 20;
        m_uiyPad = 20;

        SetScrollSizes( MM_TEXT, CSize( 0, 0 ) );
        m_rectClient.SetRect( 0, 0, 0, 0 );
        m_pointMousePress.SetPoint( -1, -1 );

        // parameter of view
        m_dMagnification = DEFAULT_MAGNIFICATION;
        m_qwLogicalXSize = 0;  // horizontal scrollbar size
        m_qwPhysicalXSize = 0; // data length * mag + xpad * 2
        m_qwPhysicalXPos = 0;  // left edge of data position
        m_dPhysicalParLogicalXSize = 1.0;

        m_cursorDrag = AfxGetApp() ->LoadStandardCursor( IDC_SIZEALL );

        // create brush and pen
        m_colorBackground = RGB( 0, 0, 0 );
        m_colorForeground = RGB( 255, 255, 255 );
        m_colorAxis = RGB( 127, 127, 127 );
        m_brushBackground.CreateSolidBrush( m_colorBackground );
        m_penForeground.CreatePen( PS_SOLID, 1, m_colorForeground );
        m_penBackground.CreatePen( PS_SOLID, 1, m_colorBackground );
        m_penAxis.CreatePen( PS_SOLID, 1, m_colorAxis );
}

CDataView::~CDataView()
{
        m_brushBackground.DeleteObject();
        delete m_pMutex;
}


BEGIN_MESSAGE_MAP( CDataView, CScrollView )
ON_WM_SIZE()
ON_WM_GETDLGCODE()
ON_WM_KEYDOWN()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_MOUSEMOVE()
ON_WM_HSCROLL()
ON_WM_MBUTTONDOWN()
ON_WM_ERASEBKGND()
END_MESSAGE_MAP()


// CDataView drawing
void CDataView::OnDraw( CDC* pDC )
{
        CNeuroManagerDoc * pDoc = ( CNeuroManagerDoc* ) GetDocument();
        // TODO: add draw code for native data here
        if ( pDoc )
        {
                // lock mutex
                m_pMutex->Lock();
                CRect rcClip;
                pDC->GetClipBox( rcClip );
                CRect rcBitmap = m_rectClient;
                pDC->DPtoLP( rcBitmap );
                CSize siz = rcBitmap.Size();
                CSize offset( rcBitmap.left, rcBitmap.top );
                rcBitmap.MoveToXY( 0, 0 );

                if ( m_bitmapBuffer.m_hObject && m_bResizeRequired )
                {
                        m_bitmapBuffer.DeleteObject();
                        m_memDC.DeleteDC();
                }
                if ( m_bitmapBuffer.m_hObject == NULL )
                {
                        m_bitmapBuffer.CreateCompatibleBitmap( pDC, rcBitmap.Width(), rcBitmap.Height() );
                        m_memDC.CreateCompatibleDC( pDC );
                        m_memDC.SelectObject( m_bitmapBuffer );
                        m_bResizeRequired = FALSE;
                        m_bRedrawRequired = TRUE;
                        m_bUseScrollDraw = FALSE;
                }
                if ( m_bRedrawRequired )
                {
                        CRgn rgn;
                        CRect rcBitmapClip = rcClip;
                        rcBitmapClip.MoveToXY( rcClip.left - offset.cx, rcClip.top - offset.cy );
                        if ( m_bUseScrollDraw && abs( m_iScrollDrawSize ) < rcBitmap.Width() )
                        {
                                ASSERT( m_iScrollDrawSize != 0 );
                                CRect rcNewClip;
                                m_memDC.ScrollDC( m_iScrollDrawSize, 0, rcBitmap, rcBitmapClip, NULL, &rcNewClip );
                                rcBitmapClip = rcNewClip;
                        }
                        rgn.CreateRectRgnIndirect( rcBitmapClip );
                        m_memDC.SelectClipRgn( &rgn );
                        Redraw( &m_memDC, &rcBitmap );
                        m_memDC.SelectClipRgn( NULL );
                        m_bRedrawRequired = FALSE;
                        m_bUseScrollDraw = FALSE;
                }
                pDC->SelectClipRgn( NULL );
                pDC->BitBlt( rcClip.left, rcClip.top, rcClip.Width(), rcClip.Height(), &m_memDC,
                             rcClip.left - offset.cx, rcClip.top - offset.cy, SRCCOPY );
                // unlock mutex
                m_pMutex->Unlock();
        }
}


// CDataView diagnostics

#ifdef _DEBUG
void CDataView::AssertValid() const
{
        CScrollView::AssertValid();
}

void CDataView::Dump( CDumpContext& dc ) const
{
        CScrollView::Dump( dc );
}
#endif //_DEBUG


// user defined methods
CFormView *CDataView::GetDataViewProperties()
{
        CDataViewSplitter * wndSplit = ( CDataViewSplitter* ) GetParent();
        if ( wndSplit == NULL )
                return NULL;
        CFormView *wndProp = wndSplit->GetDataViewPropertiesWindow();
        return wndProp;
}

BOOL CDataView::GetPaintRect( CRect &rcClip, int iView, int iTargetView, CRect &rcResult )
{
        CRect rcClient( m_rectClient );
        CRect rcTemp1( m_rectClient );
        int y_single = ( rcClient.Height() - ( int ) m_uiyPad ) / iView - ( int ) m_uiyPad;
        int y_offset = ( y_single + ( int ) m_uiyPad ) * iTargetView + ( int ) m_uiyPad;
        rcTemp1.top = y_offset;
        rcTemp1.bottom = y_offset + y_single;

        CRect rcTemp2;
        BOOL bState = rcTemp2.IntersectRect( rcTemp1, rcClient );
        if ( bState == FALSE )
                return FALSE;
        bState = rcTemp1.IntersectRect( rcClip, rcTemp2 );
        if ( bState == FALSE )
                return FALSE;
        rcResult = rcTemp1;

        return TRUE;
}

void CDataView::_paintBackground( CDC *pDC, CRect *pRectDest )
{
        // set pen and brush style for backgournd painting
        CBrush * oldbrush = pDC->SelectObject( &m_brushBackground );
        CPen *oldpen = pDC->SelectObject( &m_penBackground );

        CRect rcClip;
        pDC->GetClipBox( rcClip );
        pDC->Rectangle( rcClip );

        // restore original pen and brush style
        pDC->SelectObject( &oldbrush );
        pDC->SelectObject( &oldpen );
}

void CDataView::_paintAxis( CDC *pDC, CRect *pRectDest, UINT nView, UINT nTargetView, double ymin, double ymax )
{
        // set pen style for axis drawing
        CPen * oldpen = pDC->SelectObject( &m_penAxis );

        // initialize values
        CSize siz = pRectDest->Size();
        LONG xs, ys, xe, ye;

        LONG y_single = ( siz.cy - m_uiyPad ) / nView - m_uiyPad;
        LONG y_offset = ( y_single + m_uiyPad ) * nTargetView + m_uiyPad;
        LONG y_zero = y_single * ymax / ( ymax - ymin );
        LONG y_middle = y_offset + y_zero;

        // vertical line of zero point
        if ( m_qwPhysicalXPos <= m_uixPad )
        {
                xs = m_uixPad - m_qwPhysicalXPos + pRectDest->left;
                ys = y_offset;
                xe = xs;
                ye = y_offset + y_single;
                pDC->MoveTo( xs, ys );
                pDC->LineTo( xe, ye );
        }
        // horizontal line of zero point
        if ( 0 <= y_zero && y_zero <= y_single )
        {
                xs = pRectDest->left;
                ys = y_middle;
                if ( m_qwPhysicalXPos <= m_uixPad )
                        xs += m_uixPad - m_qwPhysicalXPos;
                xe = pRectDest->right;
                if ( m_qwPhysicalXPos + siz.cx > m_qwPhysicalXSize - m_uixPad )
                        xe -= m_qwPhysicalXPos + siz.cx - m_qwPhysicalXSize + m_uixPad;
                ye = ys;
                if ( xs < xe )
                {
                        pDC->MoveTo( xs, ys );
                        pDC->LineTo( xe, ye );
                }
        }
        // restore original pen style
        pDC->SelectObject( &oldpen );
}

void CDataView::_paintData( CDC *pDC, CRect *pRectDest, UINT nView, UINT nTargetView, UINT nCh, double ymin, double ymax )
{
        CNeuroManagerDoc * pDoc = ( CNeuroManagerDoc* ) GetDocument();
        ASSERT_VALID( pDoc );

        // set pen style for data drawing
        CPen *oldpen = pDC->SelectObject( &m_penForeground );

        // initialize values
        CSize siz = pRectDest->Size();
        LONG x, y;
        CPoint ptDrawTo, ptDrawFrom;

        LONG y_single = ( siz.cy - m_uiyPad ) / nView - m_uiyPad;
        LONG y_offset = ( y_single + m_uiyPad ) * nTargetView + m_uiyPad;
        LONG y_zero = y_single * ymax / ( ymax - ymin );
        LONG y_middle = y_offset + y_zero;
        double y_ratio = ( ( double ) y_single ) / ( ymax - ymin );

        // get clipping box
        CRect rcClip;
        pDC->GetClipBox( rcClip );

        // get data information
        QWORD len = pDoc->GetDataLength();

        // calculate range
        QWORD i, ps, pe; // data pointer
        int ls, le;      // device position
        ps = m_qwPhysicalXPos;
        if ( m_qwPhysicalXPos < m_uixPad )
        {
                ps = 0;
                ls = m_uixPad - m_qwPhysicalXPos;
        }
        else
        {
                QWORD ps2 = m_qwPhysicalXPos - m_uixPad;
                ps = ps2 / m_dMagnification;
                ls = -( ps2 - ps * m_dMagnification );
        }
        le = pRectDest->Width() - ls;
        pe = ps + le / m_dMagnification + 1;
        if ( pe > len )
                pe = len - 1;
        if ( ps < len && ps < pe )
        {
                // first data point
                i = ps;
                pDoc->AttachData( nCh );
                x = pRectDest->left + ls;
                while ( x < rcClip.left && i <= pe )
                {
                        i++;
                        x = pRectDest->left + ls + ( i - ps ) * m_dMagnification;
                }
                if ( i != ps )
                {
                        i--;
                        x = pRectDest->left + ls + ( i - ps ) * m_dMagnification;
                }
                double d = pDoc->GetData( i );
                y = y_middle - ( int ) ( d * y_ratio );
                ptDrawFrom.SetPoint( x, y );
                i++;
                LONG sy, maxy, miny, prex, prey;
                BOOL bYCache = FALSE;
                BOOL bContinue = TRUE;
                for ( ; i <= pe && bContinue; i++ )
                {
                        x = pRectDest->left + ls + ( i - ps ) * m_dMagnification;
                        if ( x > rcClip.right )
                                bContinue = FALSE;
                        d = pDoc->GetData( i );
                        y = y_middle - ( int ) ( d * y_ratio );
                        if ( ptDrawFrom.x == x )
                        {
                                if ( bYCache )
                                {
                                        maxy = ( maxy > y ) ? maxy : y;
                                        miny = ( miny < y ) ? miny : y;
                                        prey = y;
                                }
                                else
                                {
                                        prex = x;
                                        sy = prey = y;
                                        miny = maxy = y;
                                        bYCache = TRUE;
                                }
                        }
                        else
                        {
                                if ( bYCache )
                                {
                                        pDC->MoveTo( ptDrawFrom );
                                        ptDrawTo.SetPoint( prex, sy );
                                        pDC->LineTo( ptDrawTo );
                                        ptDrawFrom.SetPoint( prex, maxy );
                                        pDC->MoveTo( ptDrawFrom );
                                        ptDrawTo.SetPoint( prex, miny );
                                        pDC->LineTo( ptDrawTo );
                                        ptDrawFrom.SetPoint( prex, prey );
                                        bYCache = FALSE;
                                }
                                pDC->MoveTo( ptDrawFrom );
                                ptDrawTo.SetPoint( x, y );
                                ptDrawFrom.SetPoint( x, y );
                                pDC->LineTo( ptDrawTo );
                        }
                }
                pDoc->DetachData();
        }

        // restore original pen style
        pDC->SelectObject( oldpen );
}

void CDataView::Redraw( CDC *pDC, CRect *pRectDest )
{
        CDataViewProperties * wndProp = ( CDataViewProperties* ) GetDataViewProperties();
        ASSERT_VALID( wndProp );

        // paint background
        _paintBackground( pDC, pRectDest );

        UINT nView = wndProp->GetVisibleDataChannelSize();
        if ( nView == 0 )
        {
                // paint axis only
                _paintAxis( pDC, pRectDest, 1, 0, -1.0, 1.0 );
        }
        else
        {
                UINT nCh = 0;
                double ymin, ymax;
                CRect rcClipOrig, rcClipNew;
                pDC->GetClipBox( rcClipOrig );
                for ( UINT ii = 0; ii < nView; ii++ )
                {
                        // seek to next visible channel
                        for ( ; wndProp->GetVisibleDataChannelState( nCh ) == FALSE; nCh++ )
                                ;
                        wndProp->GetDataYAxisRange( nCh, ymin, ymax );
                        BOOL bClip = GetPaintRect( rcClipOrig, ( int ) nView, ( int ) ii, rcClipNew );
                        if ( bClip )
                        {
                                CRgn rgn;
                                rgn.CreateRectRgnIndirect( rcClipNew );
                                pDC->SelectClipRgn( &rgn );
                        }
                        // paint axis
                        _paintAxis( pDC, pRectDest, nView, ii, ymin, ymax );
                        // paint data
                        _paintData( pDC, pRectDest, nView, ii, nCh, ymin, ymax );
                        if ( bClip )
                        {
                                CRgn rgn;
                                rgn.CreateRectRgnIndirect( rcClipOrig );
                                pDC->SelectClipRgn( &rgn );
                        }
                        nCh++;
                }
        }
}

QWORD CDataView::GetCurrentDataPos() const
{
        CNeuroManagerDoc * pDoc = ( CNeuroManagerDoc* ) GetDocument();
        ASSERT_VALID( pDoc );
        QWORD pos = m_qwPhysicalXPos;
        if ( !pDoc->IsMapped() )
                return 0;
        if ( m_qwPhysicalXPos < m_uixPad )
        {
                pos = 0;
        }
        else
        {
                QWORD tmp = m_qwPhysicalXPos - m_uixPad;
                pos = tmp / m_dMagnification;
        }
        QWORD len = pDoc->GetDataLength();
        if ( pos > len )
                pos = len;
        return pos;
}

void CDataView::UpdateScrollSizes( int cx, int cy )
{
        CNeuroManagerDoc * pDoc = ( CNeuroManagerDoc* ) GetDocument();
        ASSERT_VALID( pDoc );

        CRect rcOld = m_rectClient;
        m_rectClient.SetRect( 0, 0, cx, cy );

        CSize sizeTotal = m_rectClient.Size();
        if ( pDoc->IsMapped() )
        {
                m_qwPhysicalXSize = pDoc->GetDataLength() * m_dMagnification + m_uixPad * 2 - sizeTotal.cx;
                if ( m_qwPhysicalXSize > MAX_SCROLLBAR_SIZE )
                        sizeTotal.cx = MAX_SCROLLBAR_SIZE;
                else
                        sizeTotal.cx = m_qwPhysicalXSize;
        }
        else
        {
                m_qwPhysicalXSize = m_rectClient.Width();
        }
        m_qwLogicalXSize = sizeTotal.cx;
        SetScrollSizes( MM_TEXT, sizeTotal );
        // fix y size
        CRect rcNew;
        GetClientRect( rcNew );
        if ( rcNew.bottom != sizeTotal.cy )
        {
                sizeTotal.cy = rcNew.bottom;
                SetScrollSizes( MM_TEXT, sizeTotal );
                m_rectClient.SetRect( 0, 0, cx, rcNew.bottom );
        }

        double dOld = m_dPhysicalParLogicalXSize;
        BOOL bHasHorzBar, bHasVertBar;
        CheckScrollBars( bHasHorzBar, bHasVertBar );
        int limx = ( bHasHorzBar ) ? GetScrollLimit( SB_HORZ ) : sizeTotal.cx;
        m_dPhysicalParLogicalXSize = ( double ) m_qwPhysicalXSize / ( double ) limx;

        if ( rcOld != m_rectClient || dOld != m_dPhysicalParLogicalXSize )
        {
                m_bResizeRequired = TRUE;
        }
}


void CDataView::DataViewHScrollBy( int nPos )
{
        // check horizontal scroll bar available
        BOOL bHasHorzBar, bHasVertBar;
        CheckScrollBars( bHasHorzBar, bHasVertBar );
        if ( bHasHorzBar == FALSE )
                return ;

        QWORD oldpx, newpx;
        oldpx = newpx = m_qwPhysicalXPos;
        // set new position of physical scroll bar and check range
        if ( nPos > 0 )
        {
                if ( m_qwPhysicalXPos + nPos > m_qwPhysicalXSize )
                        newpx = m_qwPhysicalXSize;
                else
                        newpx += nPos;
        }
        else
        {
                if ( m_qwPhysicalXPos < ( QWORD ) ( -nPos ) )
                        newpx = 0;
                else
                        newpx += nPos;
        }
        int oldx = GetScrollPos( SB_HORZ );
        int newx = newpx / m_dPhysicalParLogicalXSize;
        // do scroll
        if ( oldx != newx )
        {
                OnScrollBy( CSize( newx - oldx, 0 ), TRUE );
        }
        if ( oldpx != newpx )
        {
                // update scroll position
                m_qwPhysicalXPos = newpx;
                // update property panel
                UpdatePropertiesTime();
                // redraw
                m_bRedrawRequired = TRUE;

                INT64 diff = ( INT64 ) ( oldpx - newpx );
                if ( diff < INT_MAX && diff > INT_MIN )
                {
                        m_bUseScrollDraw = TRUE;
                        m_iScrollDrawSize = ( int ) diff;
                }
                else
                {
                        m_bUseScrollDraw = FALSE;
                }
                Invalidate( FALSE );
                UpdateWindow();
        }
}

void CDataView::SetMagnification( double dMag )
{
        if ( m_dMagnification == dMag )
                return ;
        if ( dMag > MAX_MAGNIFICATION || dMag < MIN_MAGNIFICATION )
        {
                ::MessageBeep( MB_OK );
        }
        else
        {
                QWORD oldpos = GetCurrentDataPos();
                QWORD newpos = oldpos * dMag;
                if ( m_qwPhysicalXPos > m_uixPad )
                        newpos += m_uixPad;
                else
                        newpos += m_qwPhysicalXPos;
                m_qwPhysicalXPos = newpos;
                m_dMagnification = dMag;
                UpdateScrollSizes( m_rectClient.Width(), m_rectClient.Height() );
                int sbPos = m_qwPhysicalXPos / m_dPhysicalParLogicalXSize;
                SetScrollPos( SB_HORZ, sbPos );
                Invalidate( FALSE );

                // buffered drawing
                m_bRedrawRequired = TRUE;
                m_bUseScrollDraw = FALSE;
        }
}

void CDataView::UpdatePropertiesTime()
{
        CNeuroManagerDoc * pDoc = ( CNeuroManagerDoc* ) GetDocument();
        ASSERT_VALID( pDoc );
        CDataViewProperties *wndProp = ( CDataViewProperties* ) GetDataViewProperties();
        if ( wndProp == NULL )
                return ;
        double dTime = 0.0;
        if ( pDoc->IsMapped() )
        {
                QWORD pos = GetCurrentDataPos();
                dTime = pDoc->GetPosTime( pos );
                wndProp->SetDataTime( dTime );
        }
}


void CDataView::RedrawRequest()
{
        // lock mutex
        m_pMutex->Lock();

        m_bRedrawRequired = TRUE;
        m_bUseScrollDraw = FALSE;
        Invalidate( FALSE );

        // unlock mutex
        m_pMutex->Unlock();
}

// CDataView message handlers

// protected methods
void CDataView::OnUpdate( CView* /*pSender*/, LPARAM /*lHint*/, CObject* /*pHint*/ )
{
        CNeuroManagerDoc * pDoc = ( CNeuroManagerDoc* ) GetDocument();
        ASSERT_VALID( pDoc );

        // lock mutex
        m_pMutex->Lock();

        m_dMagnification = DEFAULT_MAGNIFICATION;
        m_qwPhysicalXPos = 0;

        CRect rect;
        GetClientRect( rect );
        UpdateScrollSizes( rect.Width(), rect.Height() );
        SetScrollPos( SB_HORZ, 0, TRUE );

        // buffered drawing
        m_bRedrawRequired = TRUE;
        m_bUseScrollDraw = FALSE;

        // older versions of Windows* (NT 3.51 for instance)
        // fail with DEFAULT_GUI_FONT
        //if (!m_font.CreateStockObject(DEFAULT_GUI_FONT))
        //      if (!m_font.CreatePointFont(80, "MS Sans Serif"))
        //              return -1;

        // unlock mutex
        m_pMutex->Unlock();
}

BOOL CDataView::OnScrollBy( CSize sizeScroll, BOOL bDoScroll )
{
        int xOrig, x;
        int yOrig, y;

        // lock mutex
        m_pMutex->Lock();

        // don't scroll if there is no valid scroll range (ie. no scroll bar)
        CScrollBar* pBar;
        DWORD dwStyle = GetStyle();

        pBar = GetScrollBarCtrl( SB_VERT );
        if ( ( pBar != NULL && !pBar->IsWindowEnabled() ) ||
                ( pBar == NULL && !( dwStyle & WS_VSCROLL ) ) )
        {
                // vertical scroll bar not enabled
                sizeScroll.cy = 0;
        }
        pBar = GetScrollBarCtrl( SB_HORZ );
        if ( ( pBar != NULL && !pBar->IsWindowEnabled() ) ||
                ( pBar == NULL && !( dwStyle & WS_HSCROLL ) ) )
        {
                // horizontal scroll bar not enabled
                sizeScroll.cx = 0;
        }

        // adjust current x position
        xOrig = x = GetScrollPos( SB_HORZ );
        int xMax = GetScrollLimit( SB_HORZ );
        x += sizeScroll.cx;
        if ( x < 0 )
                x = 0;
        else if ( x > xMax )
                x = xMax;

        // adjust current y position
        yOrig = y = GetScrollPos( SB_VERT );
        int yMax = GetScrollLimit( SB_VERT );
        y += sizeScroll.cy;
        if ( y < 0 )
                y = 0;
        else if ( y > yMax )
                y = yMax;

        // did anything change?
        if ( x == xOrig && y == yOrig )
                return FALSE;

        if ( bDoScroll )
        {
                // do scroll and update scroll positions
                if ( x != xOrig )
                        SetScrollPos( SB_HORZ, x );
                if ( y != yOrig )
                        SetScrollPos( SB_VERT, y );
        }

        // unlock mutex
        m_pMutex->Unlock();

        return TRUE;
}


// public methods

void CDataView::OnSize( UINT nType, int cx, int cy )
{
        // lock mutex
        m_pMutex->Lock();

        CScrollView::OnSize( nType, cx, cy );
        UpdateScrollSizes( cx, cy ); // for y range adjustment

        // unlock mutex
        m_pMutex->Unlock();
}


UINT CDataView::OnGetDlgCode()
{
        // enable to input all key messages on control bar
        return DLGC_WANTALLKEYS | CScrollView::OnGetDlgCode();
}

#define KEYSTATE_SHIFT_PRESSED() (GetKeyState(VK_LSHIFT)&0x8000||GetKeyState(VK_RSHIFT)&0x8000)

void CDataView::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags )
{
        BOOL bHasHorzBar, bHasVertBar;
        CheckScrollBars( bHasHorzBar, bHasVertBar );
        if ( bHasHorzBar && ( nChar == VK_LEFT || nChar == VK_RIGHT ) )
        {
                // lock mutex
                m_pMutex->Lock();

                if ( ( GetKeyState( VK_CONTROL ) & 0x8000 ) && KEYSTATE_SHIFT_PRESSED() )
                {
                        // control + shift + Left/Right
                        // change magnificant
                        double gain = ( nChar == VK_LEFT ) ? 0.5 : 2.0;
                        double newmag = gain * m_dMagnification;
                        SetMagnification( newmag );
                }
                else
                {
                        static int nGain = 10;
                        static int nAccel = 5;
                        int gain = ( nChar == VK_LEFT ) ? -nGain : nGain;
                        // accellarate to scroll at shift key press with arrow keys
                        if ( KEYSTATE_SHIFT_PRESSED() )
                                gain *= nAccel;
                        DataViewHScrollBy( gain * nRepCnt );
                }

                // unlock mutex
                m_pMutex->Unlock();
        }
}


void CDataView::OnLButtonDown( UINT nFlags, CPoint point )
{
        // set mouse pointer
        BOOL bHasHorzBar, bHasVertBar;
        CheckScrollBars( bHasHorzBar, bHasVertBar );
        if ( bHasHorzBar )
        {
                m_pointMousePress = point;
                ::SetCursor( m_cursorDrag );
        }
        else
        {
                m_pointMousePress.SetPoint( -1, -1 );
        }
        CScrollView::OnLButtonDown( nFlags, point );
}


void CDataView::OnLButtonUp( UINT nFlags, CPoint point )
{
        // unset mouse pointer
        m_pointMousePress.SetPoint( -1, -1 );
        CScrollView::OnLButtonUp( nFlags, point );
}


void CDataView::OnMButtonDown( UINT nFlags, CPoint point )
{
        // disable to scrolling using middle button. it doesn't works.
        CWnd::OnMButtonDown( nFlags, point );
}


void CDataView::OnMouseMove( UINT nFlags, CPoint point )
{
        BOOL bHasHorzBar, bHasVertBar;
        CheckScrollBars( bHasHorzBar, bHasVertBar );
        if ( bHasHorzBar && nFlags == MK_LBUTTON )
        {
                if ( m_pointMousePress.x != -1 )
                {
                        // lock mutex
                        m_pMutex->Lock();

                        int pos = m_pointMousePress.x - point.x;
                        m_pointMousePress = point;
                        ::SetCursor( m_cursorDrag );
                        DataViewHScrollBy( pos );

                        // unlock mutex
                        m_pMutex->Lock();
                }
        }
        CScrollView::OnMouseMove( nFlags, point );
}


void CDataView::OnHScroll( UINT nSBCode, UINT nPos, CScrollBar* pScrollBar )
{
        int dx = 0;
        static const int gainLine = 3;
        static const int gainPage = 100;

        // validate pScrollBar
        if ( pScrollBar != NULL && pScrollBar->SendChildNotifyLastMsg() )
                return ;
        if ( pScrollBar != GetScrollBarCtrl( SB_HORZ ) )
                return ;

        // lock mutex
        m_pMutex->Lock();
        switch ( nSBCode )
        {
        case SB_LINELEFT:
                // scroll one line to left
                dx = -gainLine;
                break;
        case SB_LINERIGHT:
                // scroll one line to right
                dx = gainLine;
                break;
        case SB_PAGELEFT:
                // scroll one page to left
                dx = -gainPage;
                break;
        case SB_PAGERIGHT:
                // scroll one page to right
                dx = gainPage;
                break;
        case SB_THUMBTRACK:
                // scroll to nPos
                if ( m_dMagnification <= pow( 2.0, -9 ) )
                        break;
        case SB_THUMBPOSITION:
                // check needs to change logical scroll bar position
                if ( GetScrollPos( SB_HORZ ) != nPos )
                        dx = ( int ) ( ( INT64 ) ( nPos * m_dPhysicalParLogicalXSize ) - ( INT64 ) m_qwPhysicalXPos );
                break;
        default:
                break;
        }
        DataViewHScrollBy( dx );

        // unlock mutex
        m_pMutex->Unlock();
}

BOOL CDataView::OnEraseBkgnd( CDC* pDC )
{
        return TRUE; // disable to erase background
}

//BOOL CDataView::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
//{
//      CWindowsMessageToString msgConverter;
//      LPSTR lpszMsg = msgConverter.GetStringFromMsg( message );
//      if( message != 867 && message != 132) {
//      TRACE("message ID[%d] : %s\n", message, lpszMsg);
//      }
//      return CScrollView::OnWndMsg(message, wParam, lParam, pResult);
//}