// scrollerView.cpp : implementation of the CScrollerView class
//

#include "stdafx.h"
#include "scroller.h"

#include "scrollerDoc.h"
#include "scrollerView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define METHOD 0 // 0 is optimized; 1 is per line method

/////////////////////////////////////////////////////////////////////////////
// CScrollerView

IMPLEMENT_DYNCREATE(CScrollerView, CScrollView)

BEGIN_MESSAGE_MAP(CScrollerView, CScrollView)
        //{{AFX_MSG_MAP(CScrollerView)
        ON_WM_SIZE()
        ON_WM_VSCROLL()
        //}}AFX_MSG_MAP
        // Standard printing commands
        ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
        ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
        ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CScrollerView construction/destruction

CScrollerView::CScrollerView()
{
        // TODO: add construction code here

}

CScrollerView::~CScrollerView()
{
}

BOOL CScrollerView::PreCreateWindow(CREATESTRUCT& cs)
{
        // TODO: Modify the Window class or styles here by modifying
        //  the CREATESTRUCT cs

        return CScrollView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CScrollerView drawing

void CScrollerView::OnDraw(CDC* pDC)
{
#if 0 // know nothing draw -- accounts for nothing
        CScrollerDoc* pDoc = GetDocument();
        ASSERT_VALID(pDoc);
        int ct=sizeof(pDoc->list)/sizeof(pDoc->list[0]);
        pDC->SetBkMode(TRANSPARENT);
        for (int i=0;i<ct;i++)
                {
                CString s;
                s.Format("(%d)=%u",i,pDoc->list[i]);
                pDC->TextOut(0,i*lineht,s);
                }
#endif
#if METHOD==0 // optimized draw
        CScrollerDoc* pDoc = GetDocument();
        ASSERT_VALID(pDoc);
        int ct;
        pDC->SetBkMode(TRANSPARENT);
        int start=GetDeviceScrollPosition().y/lineht-1;
        if (start<0) start=0;
        CRect client;
        GetClientRect(&client);
// draw extra so scrolling works on incomplete lines
        ct=start+client.Height()/lineht+3;
        if (ct>sizeof(pDoc->list)/sizeof(pDoc->list[0]))
                ct=sizeof(pDoc->list)/sizeof(pDoc->list[0]);
        for (int i=start;i<ct;i++)
                {
                CString s;
                s.Format("(%d)=%u",i,pDoc->list[i]);
                pDC->TextOut(0,i*lineht,s);
                }
#endif
#if METHOD==1
        CScrollerDoc* pDoc = GetDocument();
        ASSERT_VALID(pDoc);
        int ct;
        pDC->SetBkMode(TRANSPARENT);
        int start=GetDeviceScrollPosition().y;
        CRect client;
        GetClientRect(&client);
// draw extra so scrolling works on incomplete lines
        ct=start+client.Height()/lineht+3;
        if (ct>sizeof(pDoc->list)/sizeof(pDoc->list[0]))
                ct=sizeof(pDoc->list)/sizeof(pDoc->list[0]);
        pDC->SetMapMode(MM_TEXT);  // destroy fake mapping mode!
        pDC->SetViewportOrg(0,0);
        pDC->SetWindowOrg(0,0);
        for (int i=start;i<ct;i++)
                {
                CString s;
                s.Format("(%d)=%u",i,pDoc->list[i]);
                pDC->TextOut(0,(i-start)*lineht,s);
                }
#endif
}

void CScrollerView::OnInitialUpdate()
{
#if METHOD==0
        CScrollView::OnInitialUpdate();
        CScrollerDoc* doc = GetDocument();
        CSize sizeTotal,sizePg;
        CRect r;
        GetClientRect(&r);
        CDC *pDC=GetDC();
        TEXTMETRIC tm;
        pDC->GetTextMetrics(&tm);
        lineht=tm.tmHeight+tm.tmExternalLeading;
        sizeTotal.cx = 100;
        sizeTotal.cy = (sizeof(doc->list)/sizeof(doc->list[0]))*lineht;
        sizePg.cx=10;
        sizePg.cy=r.Height();
        SetScrollSizes(MM_TEXT, sizeTotal,sizePg,CSize(10,lineht));
#endif
#if METHOD==1
        CScrollView::OnInitialUpdate();
        CScrollerDoc* doc = GetDocument();
        CSize sizeTotal,sizePg;
        CRect r;
        GetClientRect(&r);
        CDC *pDC=GetDC();
        TEXTMETRIC tm;
        pDC->GetTextMetrics(&tm);
        lineht=tm.tmHeight+tm.tmExternalLeading;
        sizeTotal.cx = 100;
        sizeTotal.cy = sizeof(doc->list)/sizeof(doc->list[0])+r.Height()-r.Height()/lineht;
        sizePg.cx=10;
        sizePg.cy=r.Height()/lineht;
        SetScrollSizes(MM_TEXT, sizeTotal,sizePg,CSize(10,1));
#endif
}

/////////////////////////////////////////////////////////////////////////////
// CScrollerView printing

BOOL CScrollerView::OnPreparePrinting(CPrintInfo* pInfo)
{
        // default preparation
        return DoPreparePrinting(pInfo);
}

void CScrollerView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
        // TODO: add extra initialization before printing
}

void CScrollerView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
        // TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CScrollerView diagnostics

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

void CScrollerView::Dump(CDumpContext& dc) const
{
        CScrollView::Dump(dc);
}

CScrollerDoc* CScrollerView::GetDocument() // non-debug version is inline
{
        ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CScrollerDoc)));
        return (CScrollerDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CScrollerView message handlers

void CScrollerView::OnSize(UINT nType, int cx, int cy)
{
#if METHOD==0
        int dummy;
        CScrollView::OnSize(nType, cx, cy);
        CSize sizeTotal,pg,dummysize;
        CRect r;
        GetClientRect(&r);
        pg=CSize(10,r.Height());
        GetDeviceScrollSizes(dummy,sizeTotal,dummysize,dummysize);
        SetScrollSizes(MM_TEXT, sizeTotal,pg,CSize(10,lineht));
#endif
#if METHOD==1
        CScrollView::OnSize(nType, cx, cy);
        CSize sizeTotal,pg;
        CRect r;
        CScrollerDoc *doc=GetDocument();
        GetClientRect(&r);
        pg=CSize(10,r.Height()/lineht);
        sizeTotal.cx=100;
        sizeTotal.cy=sizeof(doc->list)/sizeof(doc->list[0])+r.Height()-r.Height()/lineht;
        SetScrollSizes(MM_TEXT, sizeTotal,pg,CSize(10,1));
#endif
}

void CScrollerView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{

        CScrollView::OnVScroll(nSBCode, nPos, pScrollBar);
#if METHOD==1 // Must undo scrolling behavior
        InvalidateRect(NULL);
#endif
}

BOOL CScrollerView::OnScroll(UINT nScrollCode, UINT nPos, BOOL bDoScroll) 
{
    if (nScrollCode/256==SB_THUMBTRACK|| (nScrollCode & 0xFF)==SB_THUMBTRACK) 
	{
		SCROLLINFO sinfo;
		sinfo.cbSize=sizeof(sinfo);
		sinfo.fMask=SIF_TRACKPOS;
		::GetScrollInfo(m_hWnd,SB_VERT,&sinfo);  // MFC doesn't allow for this exactly, so call API
		nPos=sinfo.nTrackPos;
	}
	return CScrollView::OnScroll(nScrollCode, nPos, bDoScroll);
}