readervcview.cpp

Foxit Reader DLL开发的示例软件。可以很方便地实现自己的pdf viewer.

// ReaderVCView.cpp : implementation of the CReaderVCView class
//

#include "stdafx.h"
#include "ReaderVC.h"
#include "MainFrm.h"
#include "ChildFrm.h"
#include "ReaderVCDoc.h"
#include "ReaderVCView.h"

#include "GotoPageDlg.h"
#include "ZoomDlg.h"

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

/////////////////////////////////////////////////////////////////////////////
// CReaderVCView

IMPLEMENT_DYNCREATE(CReaderVCView, CView)

BEGIN_MESSAGE_MAP(CReaderVCView, CView)
	//{{AFX_MSG_MAP(CReaderVCView)
	ON_COMMAND(ID_DOC_FIRSTPAGE, OnDocFirstpage)
	ON_COMMAND(ID_DOC_GOTOPAGE, OnDocGotopage)
	ON_COMMAND(ID_DOC_LASTPAGE, OnDocLastpage)
	ON_COMMAND(ID_DOC_NEXTPAGE, OnDocNextpage)
	ON_COMMAND(ID_DOC_PREPAGE, OnDocPrepage)
	ON_COMMAND(ID_VIEW_CLOCKWISE, OnClockwise)
	ON_COMMAND(ID_VIEW_COUNTERCLOCKWISE, OnCounterclockwise)
	ON_COMMAND(ID_VIEW_ACTUALSIZE, OnViewActualSize)
	ON_COMMAND(ID_VIEW_FITPAGE, OnViewFitPage)
	ON_COMMAND(ID_VIEW_FITWIDTH, OnViewFitWidth)
	ON_COMMAND(ID_VIEW_ZOOMIN, OnViewZoomIn)
	ON_COMMAND(ID_VIEW_ZOOMOUT, OnViewZoomOut)
	ON_COMMAND(ID_VIEW_ZOOMTO, OnViewZoomTo)
	ON_COMMAND(ID_FILE_PRINT, OnFilePrint)
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_WM_KEYDOWN()
	ON_COMMAND(ID_TOOL_SNAPSHOT, OnToolSnapshot)
	ON_COMMAND(ID_TOOL_HAND, OnToolHand)
	ON_WM_SIZE()
	ON_WM_HSCROLL()
	ON_WM_VSCROLL()
	ON_WM_DESTROY()
	ON_UPDATE_COMMAND_UI(ID_DOC_FIRSTPAGE, OnUpdateDocFirstpage)
	ON_UPDATE_COMMAND_UI(ID_DOC_LASTPAGE, OnUpdateDocLastpage)
	ON_UPDATE_COMMAND_UI(ID_DOC_NEXTPAGE, OnUpdateDocNextpage)
	ON_UPDATE_COMMAND_UI(ID_DOC_PREPAGE, OnUpdateDocPrepage)
	ON_UPDATE_COMMAND_UI(ID_TOOL_HAND, OnUpdateToolHand)
	ON_UPDATE_COMMAND_UI(ID_TOOL_SNAPSHOT, OnUpdateToolSnapshot)
	ON_COMMAND(ID_VIEW_BOOKMARK, OnViewBookmark)
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CReaderVCView construction/destruction

CReaderVCView::CReaderVCView()
{
	// TODO: add construction code here
	m_pFram = NULL;

	m_pDoc = NULL;
	m_pPage = NULL;
	m_nTotalPage = 0;
	m_nRotateFlag = 0;
	m_dbScaleFactor = 1.0f;
	m_nPageIndex = -1;
	m_dbPageWidth = 0.0f;
	m_dbPageHeight = 0.0f;
	m_nStartX = 0;
	m_nStartY = 0;
	m_nActualSizeX = 0;
	m_nActualSizeY = 0;
	m_bHand = TRUE;
	m_bSnap = FALSE;
	m_ptLBDown.x = m_ptLBDown.y = 0;
	
	m_nPosH = m_nPosV = -1;
	m_rtOld.top = m_rtOld.bottom = m_rtOld.left = m_rtOld.right = 0;
	m_bBookmark = FALSE;
}

CReaderVCView::~CReaderVCView()
{
	
	if (m_pPage != NULL)
	{
		FPDF_ClosePage(m_pPage);
		m_pPage = NULL;
	}
	if (m_pDoc != NULL)
	{
		FPDF_CloseDocument(m_pDoc);
		m_pDoc = NULL;
	}

}

BOOL CReaderVCView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
	cs.style |= WS_MAXIMIZE | WS_VISIBLE | WS_VSCROLL |WS_HSCROLL;
	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CReaderVCView drawing

void CReaderVCView::OnDraw(CDC* pDC)
{
	CReaderVCDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
	DrawPage(m_nRotateFlag, pDC);
}

/////////////////////////////////////////////////////////////////////////////
// CReaderVCView printing

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

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

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

/////////////////////////////////////////////////////////////////////////////
// CReaderVCView diagnostics

#ifdef _DEBUG
void CReaderVCView::AssertValid() const
{
	CView::AssertValid();
}

void CReaderVCView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

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

/////////////////////////////////////////////////////////////////////////////
// CReaderVCView message handlers

BOOL CReaderVCView::LoadPDFPage(FPDF_DOCUMENT doc, int nIndex)
{
	if(NULL == doc) return FALSE;
	if(nIndex < 0) nIndex = 0;
	if(nIndex > m_nTotalPage) nIndex = m_nTotalPage;

	if (NULL != m_pPage)
	{
		FPDF_ClosePage(m_pPage);
		m_pPage = NULL;
	}
	m_pPage = FPDF_LoadPage(doc, nIndex);
	if(NULL == m_pPage) return FALSE;
	m_nPageIndex = nIndex;
    SetPageMetrics(m_pPage);
	


	CChildFrame *pParent = (CChildFrame *)this->GetParentFrame();
	if (pParent != NULL)
	{
		pParent->SetActiveView(this);
		SyncScroll();	
	}

	this->Invalidate(TRUE);
	return TRUE;

}

void CReaderVCView::SetPageMetrics(FPDF_PAGE pPage)
{
	if(NULL==pPage) return;
	//get pdf page width an height;
	m_dbPageWidth = FPDF_GetPageWidth(pPage);
	m_dbPageHeight = FPDF_GetPageHeight(pPage);

	CDC *pDC = GetDC();
	int ix, iy;
	ix = pDC->GetDeviceCaps(LOGPIXELSX);
	iy = pDC->GetDeviceCaps(LOGPIXELSY);
	m_nActualSizeX = m_dbPageWidth / 72 * ix + 0.5f;//convert pdf coordinates to device
	m_nActualSizeY = m_dbPageHeight / 72 * iy + 0.5f;//convert pdf coordinates to device
	ReleaseDC(pDC);

}

void CReaderVCView::SetScalFactor(double dbScal)
{
	if(dbScal > 64 ) m_dbScaleFactor = 64;
	if( dbScal < 0) m_dbScaleFactor = 0.08f;
	m_dbScaleFactor = dbScal;
}
void CReaderVCView::DrawPage(int nRotate, CDC *pDC)
{
	int nSizeX = m_nActualSizeX;
	int nSizeY = m_nActualSizeY;
	if (1 == nRotate || 3 == nRotate)
	{
		int temp = nSizeX;
		nSizeX = nSizeY;
		nSizeY = temp;
	}
	FPDF_RenderPage(pDC->m_hDC, m_pPage, m_nStartX, m_nStartY, 
		nSizeX * m_dbScaleFactor, nSizeY * m_dbScaleFactor, nRotate, 
		FPDF_ANNOT | FPDF_LCD_TEXT);
}

void CReaderVCView::GetNewPageSize(int &nsizeX, int &nsizeY)
{
	int nSizeX = m_nActualSizeX;
	int nSizeY = m_nActualSizeY;
	if (1 == m_nRotateFlag || 3 == m_nRotateFlag)
	{
		int temp = nSizeX;
		nSizeX = nSizeY;
		nSizeY = temp;
	}
	 nsizeX = nSizeX*m_dbScaleFactor;
	 nsizeY = nSizeY*m_dbScaleFactor;
}

void CReaderVCView::OnDocFirstpage() 
{

	if(m_nPageIndex == 0) return;
	this->m_nPageIndex = 0;
	this->LoadPDFPage(m_pDoc, 0);
}

void CReaderVCView::OnDocGotopage() 
{
	CGotoPageDlg dlg;
	dlg.DoModal();	
}

void CReaderVCView::OnDocLastpage() 
{
	if(m_nPageIndex == m_nTotalPage -1) return;
	this->m_nPageIndex = m_nTotalPage -1;
	LoadPDFPage(m_pDoc, m_nPageIndex);
}

void CReaderVCView::OnDocNextpage() 
{
	m_nPageIndex ++ ;
	m_nPageIndex %= m_nTotalPage;
	LoadPDFPage(m_pDoc, m_nPageIndex);

}

void CReaderVCView::OnDocPrepage() 
{
	m_nPageIndex --;
	if(m_nPageIndex < 0) m_nPageIndex = m_nTotalPage-1;
	LoadPDFPage(m_pDoc, m_nPageIndex);

}

void CReaderVCView::OnClockwise() 
{
	m_nRotateFlag ++;
	m_nRotateFlag %= 4;
	LoadPDFPage(m_pDoc, m_nPageIndex);
}

void CReaderVCView::OnCounterclockwise() 
{
	m_nRotateFlag --;
	if (m_nRotateFlag < 0) m_nRotateFlag = 3;
	LoadPDFPage(m_pDoc, m_nPageIndex);
}

BOOL CReaderVCView::SetPDFDocument(FPDF_DOCUMENT pDoc, int nPageNum)
{
	if(pDoc == NULL) return FALSE;
	m_pDoc = pDoc;
	m_nTotalPage = nPageNum;
	if(!LoadPDFPage(m_pDoc, 0)) return FALSE;
	return TRUE;
}

void CReaderVCView::GotoPage(int index)
{
	if(index < 0 || index >= m_nTotalPage){MessageBox("Invalidate index");}
	if(index == m_nPageIndex) return;
	if(!LoadPDFPage(m_pDoc, index)) return;
}

void CReaderVCView::OnViewActualSize() 
{
	m_nStartX = m_nStartY = 10;
	ScalPage(1.0f);
}

void CReaderVCView::OnViewFitPage() 
{
	m_nStartX = m_nStartY = 10;
	CRect rect;
	GetClientRect(rect);
	double dbHeight = rect.Height();	
	double dbScal = dbHeight / m_nActualSizeY;
	ScalPage(dbScal);
}

void CReaderVCView::OnViewFitWidth() 
{
	m_nStartX = m_nStartY = 10;
	CRect rect;
	GetClientRect(rect);
	double dbWidth= rect.Width();
	double dbScal = dbWidth / m_nActualSizeX;
	ScalPage(dbScal);
}

void CReaderVCView::OnViewZoomIn() 
{
	double dbScal = m_dbScaleFactor;
	dbScal += 0.25f;
	if(dbScal > 6400.0f) return;
	ScalPage(dbScal);
	
}

void CReaderVCView::OnViewZoomOut() 
{
	double dbScal = m_dbScaleFactor;
	dbScal -= 0.25f;
	if(dbScal < 0.25f) return;
	ScalPage(dbScal);
}

void CReaderVCView::OnViewZoomTo() 
{
	CZoomDlg dlg;
	dlg.DoModal();
}

void CReaderVCView::ScalPage(double dbScal)
{
	SetScalFactor(dbScal);
	CChildFrame *pParent = (CChildFrame *)this->GetParentFrame();
	if (pParent != NULL)
	{
		pParent->SetActiveView(this);
		SyncScroll();	
	}
	Invalidate(TRUE);
}





void CReaderVCView::OnFilePrint() 
{
	CString strDoc = GetDocument()->GetTitle(); 
	CPrintDialog dlg(FALSE, PD_PAGENUMS | PD_USEDEVMODECOPIES);
	dlg.m_pd.nMinPage = dlg.m_pd.nFromPage =1;
	dlg.m_pd.nMaxPage = dlg.m_pd.nToPage = m_nTotalPage;
	if (dlg.DoModal() == IDOK)
	{
		int from_page, to_page;
		if (dlg.PrintAll())              
		{
			from_page = dlg.m_pd.nMinPage;
			to_page = dlg.m_pd.nMaxPage;
		}
		else if (dlg.PrintRange())       
		{                                
			from_page = dlg.GetFromPage();
			to_page = dlg.GetToPage();
		}
		else if (dlg.PrintSelection())   
		{
			from_page = to_page = m_nPageIndex + 1;     
		}
		
		HDC printDC;
		DOCINFO docInfo;

		printDC = dlg.CreatePrinterDC();
		if(NULL == printDC) return;
		docInfo.cbSize = sizeof(DOCINFO);
		docInfo.fwType = 0;
		docInfo.lpszDatatype = NULL;
		docInfo.lpszOutput = NULL;
		docInfo.lpszDocName = strDoc;

    	if(StartDoc(printDC, &docInfo) <= 0) return;
		//FPDF_DOCUMENT pDoc = NULL;
		FPDF_PAGE pPage = NULL;
		CString str;
		for (int i=from_page-1; i<to_page; i++)
		{
			if(pPage != NULL)
			{
				FPDF_ClosePage(pPage);
				pPage = NULL;
			}
			pPage = FPDF_LoadPage(m_pDoc, i);
			double npagewidth = FPDF_GetPageWidth(m_pPage);
			double npageheight = FPDF_GetPageHeight(m_pPage);
			
			int logpixelsx,logpixelsy;
			//calculate the page size
			logpixelsx = GetDeviceCaps(printDC,LOGPIXELSX);
			logpixelsy = GetDeviceCaps(printDC,LOGPIXELSY);
			int nsizeX = npagewidth / 72 *logpixelsx + 0.5f;
			int nsizeY = npageheight / 72 *logpixelsy + 0.5f;
			
			if(StartPage(printDC) <= 0)
			{	
				str.Format("one error occured when start the page %d", i);
				MessageBox(str);
				return;
			}

			//render to print device
			FPDF_RenderPage(printDC, pPage, m_nStartX, m_nStartY, nsizeX, nsizeY, m_nRotateFlag, 0);
			
			if(EndPage(printDC) <= 0)
			{
				str.Format("one error occured when close the page %d", i);
				MessageBox(str);
				return;
			}

		}//end for
		EndDoc(printDC);
		if(!DeleteDC(printDC))// delete printDC
			MessageBox("can not delete the printer");
	}	
}

void CReaderVCView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	LoadMyCursor(1);
	m_ptLBDown = point;

	if (m_bHand)
	{
		m_nPosH = GetScrollPos(SB_HORZ);//SetScrollPos(SB_VERT, point.y, TRUE);
		m_nPosV = GetScrollPos(SB_VERT);
	}
	CView::OnLButtonDown(nFlags, point);
}