windows-xp/Source/XPSP1/NT/termsrv/admtools/winutils/tscfg/rowview.cpp

/*******************************************************************************
*
* rowview.cpp
*
* implementation of the CRowView class and CRowViewHeaderBar class
*
* Modified from the Microsoft Foundation Classes C++ library.
* Copyright (C) 1992 Microsoft Corporation
* All rights reserved.
*
* additional copyright notice: Copyright 1995, Citrix Systems Inc.
*
* $Author:   butchd  $  Butch Davis
*
* $Log:   N:\NT\PRIVATE\UTILS\CITRIX\WINUTILS\COMMON\VCS\ROWVIEW.CPP  $
*  
*     Rev 1.1   18 Jul 1995 06:50:06   butchd
*  Scrolling fix for Windows95 / MFC 3.0
*  
*     Rev 1.0   01 Mar 1995 10:54:46   butchd
*  Initial revision.
*  
*     Rev 1.0   02 Aug 1994 18:18:30   butchd
*  (Initial revision: was duplicated in each app directory).
*
*******************************************************************************/

/*
 * include files
 */
#include "stdafx.h"
#include <afxwin.h>         // MFC core and standard components
#include <afxext.h>         // MFC extensions
#include "rowview.h"
#include "resource.h"
#include <stdlib.h>
#include <limits.h> // for INT_MAX


#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif


////////////////////////////////////////////////////////////////////////////////
// CRowViewHeaderBar class implementation / construction, destruction

IMPLEMENT_DYNAMIC(CRowViewHeaderBar, CStatusBar)

CRowViewHeaderBar::CRowViewHeaderBar()
{
}


CRowViewHeaderBar::~CRowViewHeaderBar()
{
}


/*******************************************************************************
 *
 *  DoPaint - CRowViewHeaderBar member function: CStatusBar class override
 *
 *      Draw the view's header bar.
 *
 *  ENTRY:
 *
 *      pDC (input)
 *          Points to the current CDC device-context object for drawing
 *          the header bar.
 *
 *  NOTE: The view's
 *      DoPaint function.
 *
 ******************************************************************************/
void
CRowViewHeaderBar::DoPaint( CDC* pDC )
{
    /*
     * Perform the CControlBar base class' DoPaint first.
     */
    CControlBar::DoPaint(pDC);

    /*
     * Default the y position for drawing the header bar to the m_cyTopBorder
     * member variable setting and call the view's OnDrawHeaderBar() member
     * function to perform the desired header bar drawing.
     */
    int y = m_cyTopBorder;
    ((CRowView *)m_pView)->OnDrawHeaderBar( pDC, y );

}  // end CRowViewHeaderBar::DoPaint
////////////////////////////////////////////////////////////////////////////////
// CRowViewHeaderBar message map

BEGIN_MESSAGE_MAP(CRowViewHeaderBar, CStatusBar)
    //{{AFX_MSG_MAP(CRowViewHeaderBar)
#if _MFC_VER >= 0x400 
	ON_WM_PAINT()
#endif
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

////////////////////////////////////////////////////////////////////////////////
// CRowViewHeaderBar commands


////////////////////////////////////////////////////////////////////////////////
// CRowView implementation / construction, destruction

IMPLEMENT_DYNAMIC(CRowView, CScrollView)

CRowView::CRowView()
{
    m_nPrevSelectedRow = 0;
    m_bThumbTrack = TRUE;       // default to handle SB_THUMBTRACK messages.
    m_pHeaderBar = NULL;        // default to no header bar
}


CRowView::~CRowView()
{
}



int
CRowView::OnCreate( LPCREATESTRUCT lpCreateStruct )
{
    if ( CScrollView::OnCreate(lpCreateStruct) == -1 )
        return -1;
    
    /*
     * If the derived class has constructed a header bar, call CreateHeaderBar
     * to create the header-bar window and initialize.
     */
    if ( m_pHeaderBar )
        if ( !CreateHeaderBar() )
            return( -1 );
    
    return( 0 );

}  // end CRowView::OnCreate


BOOL
CRowView::CreateHeaderBar()
{
    /*
     * Invoke the CRowViewHeaderBar's Create member function (CStatusBar defined)
     * to create the header bar, which will be hooked to this document/view's
     * parent window.  Set the header bar's m_pView pointer to this view.
     */
    if ( !m_pHeaderBar->Create( GetParent(), WS_CHILD | WS_VISIBLE | CBRS_TOP,
                                IDW_HEADER_BAR ) ) {
        return ( FALSE );

    } else {

        m_pHeaderBar->m_pView = this;
        return ( TRUE );
    }
}  // end CRowView::CreateHeaderBar


////////////////////////////////////////////////////////////////////////////////
// CRowView class optional derived class override

/*******************************************************************************
 *
 *  ResetHeaderBar - CRowView member function: optional derived class override
 *
 *      Reset the header bar width and height based on the view's total width
 *      and view's row height.  Will also instruct the parent frame to
 *      recalculate it's layout based on the new header bar metrics.
 *
 *      NOTE: A derived class will typically override this member function to
 *      set the desired header bar font, then call this function.
 *
 ******************************************************************************/

void
CRowView::ResetHeaderBar()
{
    /*
     * If no header bar was created, return.
     */
    if ( !m_pHeaderBar )
        return;

    /*
     * Set the header bar's width and height.
     */
    m_pHeaderBar->SendMessage( WM_SIZE, 0, MAKELONG(m_nRowWidth, m_nRowHeight) );

    /*
     * Recalculate parent frame's layout with new header bar.
     */
    ((CFrameWnd *)m_pHeaderBar->GetParent())->RecalcLayout();

}  // end CRowView::ResetHeaderBar


////////////////////////////////////////////////////////////////////////////////
// CRowView class override member functions

/*******************************************************************************
 *
 *  OnInitialUpdate - CRowView member function: CView class override
 *
 *      Called before the view is initially displayed.
 *
 *  (Refer to the MFC CView::OnInitialUpdate documentation)
 *
 ******************************************************************************/

void
CRowView::OnInitialUpdate()
{
    m_nPrevRowCount = GetRowCount();
    m_nPrevSelectedRow = GetActiveRow();

}  // end CRowView::OnInitialUpdate


/*******************************************************************************
 *
 *  OnPrepareDC - CRowView member function: CView class override
 *
 *      Prepare the DC for screen or printer output.
 *
 *  (Refer to the MFC CView::OnPrepareDC documentation)
 *
 ******************************************************************************/

void
CRowView::OnPrepareDC( CDC* pDC,
                       CPrintInfo* pInfo )
{
    /*
     * The size of text that is displayed, printed or previewed changes
     * depending on the DC.  We explicitly call OnPrepareDC() to prepare
     * CClientDC objects used for calculating text positions and to
     * prepare the text metric member variables of the CRowView object.
     * The framework also calls OnPrepareDC() before passing the DC to
     * OnDraw().
     */
    CScrollView::OnPrepareDC( pDC, pInfo );
    CalculateRowMetrics( pDC );

}  // end CRowView::OnPrepareDC


/*******************************************************************************
 *
 *  OnDraw - CRowView member function: CView class override
 *
 *      Draw on the view as needed.
 *
 *  (Refer to the MFC CView::OnDraw documentation)
 *
 ******************************************************************************/

void
CRowView::OnDraw( CDC* pDC )
{
    /*
     * If there are no rows to draw, don't do anything.
     */
    if ( GetRowCount() == 0 )
        return;

    /*
     * The window has been invalidated and needs to be repainted;
     * or a page needs to be printed (or previewed).
     * First, determine the range of rows that need to be displayed or
     * printed by fetching the invalidated region.
     */
    int nFirstRow, nLastRow;
    CRect rectClip;
    pDC->GetClipBox( &rectClip );
    RectLPtoRowRange( rectClip, nFirstRow, nLastRow, TRUE );

    /*
     * Draw each row in the invalidated region of the window,
     * or on the printed (previewed) page.
     */
    int nActiveRow = GetActiveRow();
    int nRow, y;
    int nLastViewableRow = LastViewableRow();
    for ( nRow = nFirstRow, y = m_nRowHeight * nFirstRow;
          nRow <= nLastRow;
          nRow++, y += m_nRowHeight ) {

        if ( nRow > nLastViewableRow ) {

            CString strWarning;
            strWarning.LoadString( IDS_TOO_MANY_ROWS );
            pDC->TextOut( 0, y, strWarning );
            break;
        }

        OnDrawRow( pDC, nRow, y, nRow == nActiveRow );
    }

}  // end CRowView::OnDraw


/*******************************************************************************
 *
 *  OnPreparePrinting - CRowView member function: CView class override
 *
 *      Prepare the view for printing or print preview.
 *
 *  (Refer to the MFC CView::OnPreparePrinting documentation)
 *
 ******************************************************************************/

BOOL
CRowView::OnPreparePrinting( CPrintInfo* pInfo )
{
    return ( DoPreparePrinting( pInfo ) );

}  // end CRowView::OnPreparePrinting


/*******************************************************************************
 *
 *  OnBeginPrinting - CRowView member function: CView class override
 *
 *      Setup before beginning to print.
 *
 *  (Refer to the MFC CView::OnBeginPrinting documentation)
 *
 ******************************************************************************/

void
CRowView::OnBeginPrinting( CDC* pDC,
                           CPrintInfo* pInfo )
{
    /*
     * OnBeginPrinting() is called after the user has committed to
     * printing by OK'ing the Print dialog, and after the framework
     * has created a CDC object for the printer or the preview view.
     */

    /*
     * This is the right opportunity to set up the page range.
     * Given the CDC object, we can determine how many rows will
     * fit on a page, so we can in turn determine how many printed
     * pages represent the entire document.
     */

    int nPageHeight = pDC->GetDeviceCaps(VERTRES);
    CalculateRowMetrics(pDC);
    m_nRowsPerPrintedPage = nPageHeight / m_nRowHeight;

    int nPrintableRowCount = LastViewableRow() + 1;
    if ( GetRowCount() < nPrintableRowCount )
        nPrintableRowCount = GetRowCount();

    pInfo->SetMaxPage( (nPrintableRowCount + m_nRowsPerPrintedPage - 1)
                        / m_nRowsPerPrintedPage );
    /*
     * Start previewing at page #1.
     */
    pInfo->m_nCurPage = 1;
}  // end CRowView::OnBeginPrinting


/*******************************************************************************
 *
 *  OnPrint - CRowView member function: CView class override
 *
 *      Print or preview a page of the view's document.
 *
 *  (Refer to the MFC CView::OnPrint documentation)
 *
 ******************************************************************************/

void
CRowView::OnPrint( CDC* pDC,
                   CPrintInfo* pInfo )
{
    /*
     * Print the rows for the current page.
     */
    int yTopOfPage = (pInfo->m_nCurPage -1) * m_nRowsPerPrintedPage
                        * m_nRowHeight;

    /*
     * Orient the viewport so that the first row to be printed
     * has a viewport coordinate of (0,0).
     */
    pDC->SetViewportOrg(0, -yTopOfPage);

    /*
     * Draw as many rows as will fit on the printed page.
     * Clip the printed page so that there is no partially shown
     * row at the bottom of the page (the same row which will be fully
     * shown at the top of the next page).
     */
    int nPageWidth = pDC->GetDeviceCaps(HORZRES);
    CRect rectClip = CRect(0, yTopOfPage, nPageWidth, 
         yTopOfPage + m_nRowsPerPrintedPage * m_nRowHeight);
    pDC->IntersectClipRect(&rectClip);
    OnDraw(pDC);

}  // end CRowView::OnPrint


/////////////////////////////////////////////////////////////////////////////
// CRowView operations

/*******************************************************************************
 *
 *  UpdateRow - CRowView member function: operation
 *
 *      Handle scrolling and invalidation of the specified row, in preparation
 *      for the OnDraw function.
 *
 *  ENTRY:
 *
 *      nInvalidRow (input)
 *          Row to update.
 *
 *  EXIT:
 *
 ******************************************************************************/

void
CRowView::UpdateRow( int nInvalidRow )
{
    int nRowCount = GetRowCount();

    /*
     * If the number of rows has changed, then adjust the scrolling range.
     */
    if (nRowCount != m_nPrevRowCount)
    {
        UpdateScrollSizes();
        m_nPrevRowCount = nRowCount;
    }

    /*
     * When the currently selected row changes:
     * scroll the view so that the newly selected row is visible, and
     * ask the derived class to repaint the selected and previously
     * selected rows.
     */
    CClientDC dc(this);
    OnPrepareDC(&dc);

    /*
     * Determine the range of the rows that are currently fully visible
     * in the window.  We want to do discrete scrolling by so that
     * the next or previous row is always fully visible.
     */
    int nFirstRow, nLastRow;
    CRect rectClient;
    GetClientRect( &rectClient );
    dc.DPtoLP( &rectClient );
    RectLPtoRowRange( rectClient, nFirstRow, nLastRow, FALSE );

    /*
     * If necessary, scroll the window so the newly selected row is
     * visible.  MODIFICATION: set the pt.x to the left visible x point
     * in the row (not 0), so that the ScrollToDevicePosition() call won't
     * automatically perform a horizontal scroll (very annoying to user).
     */
    POINT pt;
    pt.x = rectClient.left;
    BOOL bNeedToScroll = TRUE;

    if ( nInvalidRow < nFirstRow ) {
    
        /*
         * The newly selected row is above those currently visible
         * in the window.  Scroll so the newly selected row is at the
         * very top of the window.  The last row in the window might
         * be only partially visible.
         */
        pt.y = RowToYPos(nInvalidRow);

    } else if ( nInvalidRow > nLastRow ) {
    
        /*
         * The newly selected row is below those currently visible
         * in the window.  Scroll so the newly selected row is at the
         * very bottom of the window.  The first row in the window might
         * be only partially visible.
         */
        pt.y = max( 0, RowToYPos(nInvalidRow+1) - rectClient.Height() );

    } else {

        bNeedToScroll = FALSE;
    }

    if ( bNeedToScroll ) {

        /*
         * Scrolling will cause the newly selected row to be
         * redrawn in the invalidated area of the window.
         */
        ScrollToDevicePosition(pt);

        /*
         * Need to prepare the DC again because ScrollToDevicePosition()
         * will have changed the viewport origin.  The DC is used some
         * more below.
         */
        OnPrepareDC(&dc);
    }

    CRect rectInvalid = RowToWndRect( &dc, nInvalidRow );
    InvalidateRect( &rectInvalid );

    /*
     * Give the derived class an opportunity to repaint the
     * previously selected row, perhaps to un-highlight it.
     */
    int nSelectedRow = GetActiveRow();
    if (m_nPrevSelectedRow != nSelectedRow) {

        CRect rectOldSelection = RowToWndRect(&dc, m_nPrevSelectedRow);
        InvalidateRect(&rectOldSelection);
        m_nPrevSelectedRow = nSelectedRow;
    }

}  // end CRowView::UpdateRow


/*******************************************************************************
 *
 *  IsScrollingNeeded - CRowView member function: operation
 *
 *      Determine if the client window of this view is small enough in a
 *      HORIZONTAL or VERTICAL direction to require scrolling to see the
 *      entire view.  This function is mainly used to support the operation
 *      of 'scrolling keys' (non-mouse generated scrolling commands).
 *
 *  ENTRY:
 *
 *      nBar (input)
 *          SB_HORZ or SB_VERT: to indicate which scrolling direction to check.
 *
 *  EXIT:
 *
 *      TRUE if scrolling is needed in the specified direction.
 *      FALSE if no scrolling is needed in the specified direction.
 *
 ******************************************************************************/

BOOL
CRowView::IsScrollingNeeded( int nBar )
{
    CRect rectClient;
    CSize sizeTotal;

    GetClientRect( &rectClient );
    sizeTotal = GetTotalSize();

    if ( nBar == SB_HORZ ) {
    
        if ( sizeTotal.cx > rectClient.right )
            return ( TRUE );
        else
            return (FALSE );

    } else {

        if ( sizeTotal.cy > rectClient.bottom )
            return ( TRUE );
        else
            return (FALSE );
    }
}  // end CRowView::IsScrollingNeeded


#ifndef MFC300
/*******************************************************************************
 *
 *  GetScrollLimit - CRowView member function: operation (MFC 2.x stub)
 *
 *      MFC 3.0 provides a GetScrollLimit() member function that properly
 *      handles Windows95 scrollbar controls if running on Windows95.  This
 *      stub is provided for
 *
 *  ENTRY:
 *      nBar (input)
 *          SB_HORZ or SB_VERT: to indicate which scrolling direction to check.
 *  EXIT:
 *      Returns the nMax value from the standard Windows GetScrollLimit() API.
 *      Also contains an ASSERT to check for nMin != 0.
 *
 ******************************************************************************/

int
CRowView::GetScrollLimit( int nBar )
{
    int nMin, nMax;
    GetScrollRange(nBar, &nMin, &nMax);
    ASSERT(nMin == 0);
    return nMax;

}  // end CRowView::GetScrollLimit
#endif


void
CRowView::CalculateRowMetrics( CDC* pDC )
{
    GetRowWidthHeight( pDC, m_nRowWidth, m_nRowHeight );

}  // end CRowView::CalculateRowMetrics


void
CRowView::UpdateScrollSizes()
{
    /*
     * UpdateScrollSizes() is called when it is necessary to adjust the
     * scrolling range or page/line sizes.  There are two occassions
     * where this is necessary:  (1) when a new row is effected (added,
     * deleted, or changed) -- see UpdateRow()-- and (2) when the window size
     * changes-- see OnSize().
     */
    CRect rectClient;
    GetClientRect( &rectClient );

    CClientDC dc( this );
    CalculateRowMetrics( &dc );

    /*
     * The vert scrolling range is the total display height of all
     * of the rows.
     */
    CSize sizeTotal( m_nRowWidth, 
                     m_nRowHeight * (min( GetRowCount(), LastViewableRow() )) );

    /*
     * The vertical per-page scrolling distance is equal to the
     * how many rows can be displayed in the current window, less
     * one row for paging overlap.
     */
    CSize sizePage( m_nRowWidth/5,
                    max( m_nRowHeight,
                         ((rectClient.bottom/m_nRowHeight)-1)*m_nRowHeight ) );

    /*
     * We'll also calculate the number of rows that the view should be scrolled
     * during PageUp / PageDown.  This number will always be at least 1.
     */
    m_nPageScrollRows = (m_nPageScrollRows =
                         ((rectClient.bottom / m_nRowHeight)-1)) >= 1 ?
                         m_nPageScrollRows : 1;

    /*
     * The vertical per-line scrolling distance is equal to the
     * height of the row.
     */
    CSize sizeLine( m_nRowWidth/20, m_nRowHeight );

    SetScrollSizes( MM_TEXT, sizeTotal, sizePage, sizeLine );

}  // end CRowView::UpdateScrollSizes


int
CRowView::RowToYPos( int nRow )
{
    return ( nRow * m_nRowHeight );

}  // end CRowView::RowToYPos


CRect
CRowView::RowToWndRect( CDC* pDC,
                        int nRow )
{
    /*
     * MODIFICATION: Set right end of returned rectangle to max of end of row,
     * or screen width.  This will assure full update in case of horizontall
     * scrolling on very wide rows (> screen width).
     */
    int nHorzRes = pDC->GetDeviceCaps(HORZRES);
    CRect rect( 0, nRow * m_nRowHeight, 
                max( m_nRowWidth, nHorzRes ), (nRow + 1) * m_nRowHeight );
    pDC->LPtoDP( &rect );
    return rect;

}  // end CRowView::RowToWndRect


int
CRowView::LastViewableRow()
{
    return ( (INT_MAX / m_nRowHeight) - 1 );
}  // end CRowView::LastViewableRow


void
CRowView::RectLPtoRowRange( const CRect& rect,
                            int& nFirstRow,
                            int& nLastRow,
                            BOOL bIncludePartiallyShownRows )
{
    int nRounding = bIncludePartiallyShownRows? 0 : (m_nRowHeight - 1);

    nFirstRow = (rect.top + nRounding) / m_nRowHeight;
    nLastRow = min( (rect.bottom - nRounding) / m_nRowHeight,
                    GetRowCount() - 1 );
}  // end CRowView::RectLPtoRowRange


/////////////////////////////////////////////////////////////////////////////
// CRowView message map

BEGIN_MESSAGE_MAP(CRowView, CScrollView)
    //{{AFX_MSG_MAP(CRowView)
    ON_WM_KEYDOWN()
    ON_WM_SIZE()
    ON_WM_LBUTTONDOWN()
    ON_WM_HSCROLL()
    ON_WM_CREATE()
    ON_WM_VSCROLL()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CRowView commands

/*******************************************************************************
 *
 *  OnSize - CRowView member function: command (override of CWnd)
 *
 *      Processes size change message.
 *
 *  ENTRY:
 *
 *      (Refer to CWnd::OnSize documentation)
 *
 *  EXIT:
 *
 ******************************************************************************/

void
CRowView::OnSize( UINT nType,
                  int cx,
                  int cy )
{
    UpdateScrollSizes();
    CScrollView::OnSize(nType, cx, cy);

}  // end CRowView::OnSize


/*******************************************************************************
 *
 *  OnKeyDown - CRowView member function: command (override of CWnd)
 *
 *      Processes list scrolling / selection via keyboard input.
 *
 *  ENTRY:
 *
 *      (Refer to CWnd::OnKeyDown documentation)
 *
 *  EXIT:
 *
 ******************************************************************************/

void
CRowView::OnKeyDown( UINT nChar,
                     UINT nRepCnt,
                     UINT nFlags )
{
    int nNewRow;

    switch ( nChar ) {

        case VK_HOME:
            ChangeSelectionToRow(0);
            break;

        case VK_END:
            ChangeSelectionToRow(GetRowCount() - 1);
            break;

        case VK_UP:
            ChangeSelectionNextRow(FALSE);
            break;

        case VK_DOWN:
            ChangeSelectionNextRow(TRUE);
            break;
            
        case VK_PRIOR:
            /*
             * Determine a new row that is one 'pageup' above our currently
             * active row and make it active.
             */
            nNewRow = (nNewRow = GetActiveRow() - m_nPageScrollRows) >
                       0 ? nNewRow : 0;
            ChangeSelectionToRow(nNewRow);
            break;

        case VK_NEXT:
            /*
             * Determine a new row that is one 'pagedown' below our currently
             * active row and make it active.
             */
            nNewRow = (nNewRow = GetActiveRow() + m_nPageScrollRows) <
                       GetRowCount() ? nNewRow : GetRowCount() - 1;
            ChangeSelectionToRow(nNewRow);
            break;

        case VK_LEFT:
        
            /*
             * Scroll page-left.
             */
            if ( IsScrollingNeeded(SB_HORZ) ) {
            
                OnHScroll( SB_PAGELEFT, 0, GetScrollBarCtrl(SB_HORZ) );
                return;
            }
            break;

        case VK_RIGHT:
        
            /*
             * Scroll page-right.
             */
            if ( IsScrollingNeeded(SB_HORZ) ) {
            
                OnHScroll(SB_PAGERIGHT, 0, GetScrollBarCtrl(SB_HORZ));
                return;
            }
            break;

        default:

            /*
             * Call the CScrollView OnKeyDown function for keys not
             * specifically handled here.
             */
            CScrollView::OnKeyDown( nChar, nRepCnt, nFlags );
    }

}  // end CRowView::OnKeyDown


/*******************************************************************************
 *
 *  OnLButtonDown - CRowView member function: command (override of CWnd)
 *
 *      Processes left mouse button for list item selection.
 *
 *  ENTRY:
 *
 *      (Refer to CWnd::OnLButtonDown documentation)
 *
 *  EXIT:
 *
 ******************************************************************************/

void
CRowView::OnLButtonDown( UINT nFlags,
                         CPoint point )
{
    CClientDC dc(this);
    OnPrepareDC(&dc);
    dc.DPtoLP(&point);
    CRect rect(point, CSize(1,1));

    int nFirstRow, nLastRow;
    RectLPtoRowRange(rect, nFirstRow, nLastRow, TRUE);

    if (nFirstRow <= (GetRowCount() - 1))
        ChangeSelectionToRow(nFirstRow);

}  // end CRowView::OnLButtonDown


/*******************************************************************************
 *
 *  OnHScroll - CRowView member function: command (override of CScrollView)
 *
 *      Handles horizontal scrolling message.  The CScrollView member function
 *      is overriden to allow us to call the CRowView::OnScroll override during
 *      a Hscroll message.
 *
 *  ENTRY:
 *
 *      (Refer to CWnd::OnHScroll documentation)
 *
 *  EXIT:
 *
 ******************************************************************************/

void
CRowView::OnHScroll( UINT nSBCode,
                     UINT nPos,
                     CScrollBar* pScrollBar )
{
    VERIFY( pScrollBar == GetScrollBarCtrl(SB_HORZ) );    // may be null
    OnScroll( SB_HORZ, nSBCode, nPos );

}  // end CRowView::OnHScroll


/*******************************************************************************
 *
 *  OnVScroll - CRowView member function: command (override of CScrollView)
 *
 *      Handles vertical scrolling message.  The CScrollView member function is
 *      overriden to allow us to call the CRowView::OnScroll override during a
 *      Vscroll message.
 *
 *  ENTRY:
 *
 *      (Refer to CWnd::OnVScroll documentation)
 *
 *  EXIT:
 *
 ******************************************************************************/

void
CRowView::OnVScroll( UINT nSBCode,
                     UINT nPos,
                     CScrollBar* pScrollBar )
{
    VERIFY( pScrollBar == GetScrollBarCtrl(SB_HORZ) );    // may be null
    OnScroll( SB_VERT, nSBCode, nPos );

}  // end CRowView::OnVScroll


/*******************************************************************************
 *
 *  OnScroll - CRowView member function: command (override of CScrollView)
 *
 *      Processes horizontal scrolling.  The CScrollView member function
 *      is overriden to properly scroll the header bar (if it is defined) and
 *      to handle or ignore SB_THUMBTRACK scroll messages.
 *
 *  ENTRY:
 *      nBar (input)
 *          SB_HORZ or SB_VERT.
 *      nSBCode (input)
 *          Scroll bar code.
 *      nPos (input)
 *          Scroll-box position for SB_THUMBTRACK handling.
 *  EXIT:
 *
 *
 *  NOTE: This code is a slight modificaton of the CScrollView::OnScroll code
 *        found in the VIEWSCRL.CPP MFC 2.5 source.  The GetScrollLimit()
 *        function has been added to handle Windows95 scrollbar controls
 *        (when built with MFC 3.0 and above - MFC300 defined).
 *
 ******************************************************************************/

void
CRowView::OnScroll( int nBar,
                    UINT nSBCode,
                    UINT nPos )
{
    VERIFY(nBar == SB_HORZ || nBar == SB_VERT);
    BOOL bHorz = (nBar == SB_HORZ);

    int zOrig, z;   // z = x or y depending on 'nBar'
    int zMax;
    zOrig = z = GetScrollPos(nBar);
    zMax = GetScrollLimit(nBar);
    if (zMax <= 0)
    {
        TRACE0("Warning: no scroll range - ignoring scroll message\n");
        VERIFY(z == 0);     // must be at top
        return;
    }

    switch (nSBCode)
    {
    case SB_TOP:
        z = 0;
        break;

    case SB_BOTTOM:
        z = zMax;
        break;
        
    case SB_LINEUP:
        z -= bHorz ? m_lineDev.cx : m_lineDev.cy;
        break;

    case SB_LINEDOWN:
        z += bHorz ? m_lineDev.cx : m_lineDev.cy;
        break;

    case SB_PAGEUP:
        z -= bHorz ? m_pageDev.cx : m_pageDev.cy;
        break;

    case SB_PAGEDOWN:
        z += bHorz ? m_pageDev.cx : m_pageDev.cy;
        break;

    case SB_THUMBTRACK:

        /*
         * If we're not handling the SB_THUMBTRACK messages, return.
         */
        if ( !m_bThumbTrack )
            return;

        z = nPos;
        break;

    case SB_THUMBPOSITION:
        z = nPos;
        break;

    default:        // ignore other notifications
        return;
    }

    if (z < 0)
        z = 0;
    else if (z > zMax)
        z = zMax;

    if (z != zOrig)
    {
        if (bHorz) {

            ScrollWindow(-(z-zOrig), 0);

            /*
             * If this view has a header bar, scroll it to match the view.
             */
            if ( m_pHeaderBar )
                m_pHeaderBar->ScrollWindow( -(z-zOrig), 0 );

        } else
            ScrollWindow(0, -(z-zOrig));

        SetScrollPos(nBar, z);
        UpdateWindow();

        /*
         * If this view has a header bar, update it now.
         */
        if ( m_pHeaderBar )
            m_pHeaderBar->UpdateWindow();
    }
}  // end CRowView::OnScroll

#if _MFC_VER >= 0x400 

void CRowViewHeaderBar::OnPaint() 
{
	CPaintDC dc(this); // device context for painting
	
	// TODO: Add your message handler code here
	
	// Do not call CStatusBar::OnPaint() for painting messages
   	DoPaint(&dc);      
}

#endif