Merge XFA to PDFium master at 4dc95e7 on 10/28/2014

1 files changed, 3750 insertions, 0 deletions

diff --git a/xfa_test/FormFiller_Test/ReaderVCView.cpp b/xfa_test/FormFiller_Test/ReaderVCView.cpp
new file mode 100644
index 0000000000..ef0b58bfbb
--- /dev/null
+++ b/xfa_test/FormFiller_Test/ReaderVCView.cpp
@@ -0,0 +1,3750 @@
+// 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"

+#include "FindDlg.h"

+#include "ConvertDlg.h"

+#include "JS_ResponseDlg.h"

+#include "TestJsDlg.h"

+//#include "../../include/pp_event.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_EDIT_FIND, OnEditFind)

+	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_SELECT, OnToolSelect)

+	ON_COMMAND(ID_TOOL_HAND, OnToolHand)

+	ON_COMMAND(ID_TOOL_PDF2TXT, OnToolPdf2txt)

+	ON_WM_SIZE()

+	ON_WM_HSCROLL()

+	ON_WM_VSCROLL()

+	ON_COMMAND(ID_TOOL_EXTRACTLINKS, OnToolExtractlinks)

+	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_UPDATE_COMMAND_UI(ID_TOOL_SELECT, OnUpdateToolSelect)

+	ON_COMMAND(ID_VIEW_BOOKMARK, OnViewBookmark)

+	ON_WM_MOUSEWHEEL()

+	ON_WM_CONTEXTMENU()

+	ON_COMMAND(ID_EDIT_COPY, OnEditCopy)

+	ON_COMMAND(ID_RENDERBITMAP, OnRenderbitmap)

+	ON_COMMAND(ID_EXPORT_PDF_TO_BITMAP, OnExportPdfToBitmap)

+	ON_WM_CHAR()

+	ON_WM_KEYUP()

+	ON_COMMAND(ID_FILE_SAVE, OnFileSave)

+	ON_COMMAND(IDM_Test_JS, OnTestJS)

+	ON_COMMAND(TEST_PRINT_METALFILE, OnPrintMetalfile)

+	//}}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

+void Sample_PageToDevice(struct _FPDF_FORMFILLINFO* pThis,FPDF_PAGE page,double page_x,double page_y, int* device_x, int* device_y)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->PageToDeviceImpl(page, page_x, page_y, device_x, device_y);

+	}

+	//((CReaderVCView*)pThis)->PageToDeviceImpl(page, page_x, page_y, device_x, device_y);

+}

+

+void Sample_Invalidate(struct _FPDF_FORMFILLINFO* pThis,FPDF_PAGE page, double left, double top, double right, double bottom)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->InvalidateImpl(page,left, top, right, bottom);

+	}

+	//((CReaderVCView*)pThis)->InvalidateImpl(page,left, top, right, bottom);

+}

+

+void Sample_OutputSelectedRect(struct _FPDF_FORMFILLINFO* pThis,FPDF_PAGE page, double left, double top, double right, double bottom)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->OutputSelectedRectImpl(page,left, top, right, bottom);

+	}

+}

+

+void Sample_DeviceToPage(struct _FPDF_FORMFILLINFO* pThis,FPDF_PAGE page,int device_x, int device_y, double* page_x, double* page_y)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->DeviceToPageImpl(page, device_x, device_y, page_x, page_y);

+	}

+	//((CReaderVCView*)pThis)->DeviceToPageImpl(page, device_x, device_y, page_x, page_y);

+}

+/* /* Remove by Amy Lin 20100913, Since we don't this the FFI_SetCaret any more.

+void Sample_SetCaret(struct _FPDF_FORMFILLINFO* pThis,FPDF_PAGE page,double page_x, double page_y, int nWidth, int nHeight)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->SetCaretImpl(page, page_x, page_y, nWidth,  nHeight);

+	}

+	//((CReaderVCView*)pThis)->SetCaretImpl(page, page_x, page_y, nWidth,  nHeight);

+}

+*/

+void Sample_Release(struct _FPDF_FORMFILLINFO* pThis)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->ReleaseImpl();

+	}

+	//((CReaderVCView*)pThis)->ReleaseImpl();

+}

+

+

+int Sample_SetTimer(struct _FPDF_FORMFILLINFO* pThis, int uElapse, TimerCallback lpTimerFunc)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->SetTimerImpl(uElapse, lpTimerFunc);

+	}else{

+		return -1;

+	}

+	//return ((CReaderVCView*)pThis)->SetTimerImpl(uElapse, lpTimerFunc);

+}

+

+void Sample_KillTimer(struct _FPDF_FORMFILLINFO* pThis,int nID)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->KillTimerImpl(nID);

+	}

+	//((CReaderVCView*)pThis)->KillTimerImpl(nID);

+}

+

+void Sample_SetCursor(struct _FPDF_FORMFILLINFO* pThis,int nCursorType)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->SetCurorImpl(nCursorType);

+	}

+	//((CReaderVCView*)pThis)->SetCurorImpl(nCursorType);

+}

+

+void Sample_OnChange(struct _FPDF_FORMFILLINFO* pThis)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		pView->OnChangeImpl();

+	}

+}

+FPDF_BOOL	Sample_IsSHIFTKeyDown(struct _FPDF_FORMFILLINFO* pThis)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->IsSHIFTKeyDownImpl();

+	}

+	return FALSE;

+}

+FPDF_BOOL	Sample_IsCTRLKeyDown(struct _FPDF_FORMFILLINFO* pThis)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->IsCTRLKeyDownImpl();

+	}

+	return FALSE;

+}

+FPDF_BOOL	Sample_IsALTKeyDown(struct _FPDF_FORMFILLINFO* pThis) 

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->IsALTKeyDownImpl();

+	}

+	return FALSE;

+}

+FPDF_BOOL	Sample_IsINSERTKeyDown(struct _FPDF_FORMFILLINFO* pThis) 

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->IsINSERTKeyDownImpl();

+	}

+	return FALSE;

+}

+

+FPDF_PAGE Sample_GetPage(struct _FPDF_FORMFILLINFO* pThis,FPDF_DOCUMENT document, int nPageIndex)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->GetPageImpl(document,nPageIndex);

+	}

+	return NULL;

+}

+

+FPDF_PAGE Sample_GetCurrentPage(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->GetCurrentPageImpl(document);

+	}

+	return NULL;

+}

+

+int Sample_GetRotation(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->GetRotationImpl(page);

+	}

+	return NULL;

+}

+FPDF_SYSTEMTIME Sample_GetLocalTime(struct _FPDF_FORMFILLINFO* pThis)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		return pView->GetLocalTimeImpl();

+	}

+	return FPDF_SYSTEMTIME();

+}

+

+void SampleRelease(struct _FPDF_SYSFONTINFO* pThis)

+{

+	((CSampleFontInfo*)pThis)->ReleaseImpl();

+}

+

+void SampleEnumFonts(struct _FPDF_SYSFONTINFO* pThis, void* pMapper)

+{

+	((CSampleFontInfo*)pThis)->EnumFontsImpl(pMapper);

+}

+

+void* SampleMapFont(struct _FPDF_SYSFONTINFO* pThis, int weight, int bItalic, int charset, int pitch_family, 

+						const char* face, int* bExact)

+{

+	return ((CSampleFontInfo*)pThis)->MapFontImpl(weight, bItalic, charset, pitch_family, face, bExact);

+}

+

+unsigned long SampleGetFontData(struct _FPDF_SYSFONTINFO* pThis, void* hFont,

+								unsigned int table, unsigned char* buffer, unsigned long buf_size)

+{

+	return ((CSampleFontInfo*)pThis)->GetFontDataImpl(hFont, table, buffer, buf_size);

+}

+

+unsigned long SampleGetFaceName(struct _FPDF_SYSFONTINFO* pThis, void* hFont, char* buffer, unsigned long buf_size)

+{

+	return ((CSampleFontInfo*)pThis)->GetFaceNameImpl(hFont, buffer, buf_size);

+}

+

+int SampleGetFontCharset(struct _FPDF_SYSFONTINFO* pThis, void* hFont)

+{

+	return ((CSampleFontInfo*)pThis)->GetFontCharsetImpl(hFont);

+}

+

+void SampleDeleteFont(struct _FPDF_SYSFONTINFO* pThis, void* hFont)

+{

+	((CSampleFontInfo*)pThis)->DeleteFontImpl(hFont);

+}

+

+void SetSampleFontInfo()

+{

+	CSampleFontInfo* pFontInfo = new CSampleFontInfo;

+	pFontInfo->version = 1;

+	pFontInfo->DeleteFont = SampleDeleteFont;

+	pFontInfo->EnumFonts = SampleEnumFonts;

+	pFontInfo->GetFaceName = SampleGetFaceName;

+	pFontInfo->GetFont = NULL;

+	pFontInfo->GetFontCharset = SampleGetFontCharset;

+	pFontInfo->GetFontData = SampleGetFontData;

+	pFontInfo->MapFont = SampleMapFont;

+	pFontInfo->Release = SampleRelease;

+	FPDF_SetSystemFontInfo(pFontInfo);

+}

+

+void 	Sample_ExecuteNamedAction(struct _FPDF_FORMFILLINFO* pThis, FPDF_BYTESTRING namedAction)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if ( pView )

+	{

+		 pView->ExecuteNamedActionImpl(namedAction);

+	}

+

+}

+void CReaderVCView::ExecuteNamedActionImpl(FPDF_BYTESTRING namedaction)

+{

+	if(strcmp("Print", (LPCSTR)namedaction) == 0)

+		OnFilePrint();

+}

+void CReaderVCView::OutputSelectedRectImpl(FPDF_PAGE page, double left, double top, double right, double bottom)

+{

+

+	if(page == m_pPage)

+	{

+

+ 		int device_left, device_top, device_right, device_bottom;

+		

+		int nActualRangeX = 0;

+		int nActualRangeY = 0;

+		if ( m_nRotateFlag % 2 == 0 )

+		{

+			nActualRangeX = m_nActualSizeX;

+			nActualRangeY = m_nActualSizeY;

+		}else{

+			nActualRangeX = m_nActualSizeY;

+			nActualRangeY = m_nActualSizeX;

+		}

+		

+		FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+			(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, left, top, &device_left, &device_top);

+		

+		FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+			(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, right, bottom, &device_right, &device_bottom);

+		

+		CRect rc(device_left,device_top, device_right, device_bottom);

+

+

+

+		m_SelectArray.Add(rc);

+

+

+	}

+}

+

+void		Sample_Release(FPDF_LPVOID clientData)

+{

+	if (!clientData) return;

+

+	fclose(((FPDF_FILE*)clientData)->file);

+	delete ((FPDF_FILE*)clientData);

+}

+

+FPDF_DWORD	Sample_GetSize(FPDF_LPVOID clientData)

+{

+	if (!clientData) return 0;

+

+	long curPos = ftell(((FPDF_FILE*)clientData)->file);

+	fseek(((FPDF_FILE*)clientData)->file, 0, SEEK_END);

+	long size = ftell(((FPDF_FILE*)clientData)->file);

+	fseek(((FPDF_FILE*)clientData)->file, curPos, SEEK_SET);

+

+	return (FPDF_DWORD)size;

+}

+

+FPDF_RESULT	Sample_ReadBlock(FPDF_LPVOID clientData, FPDF_DWORD offset, FPDF_LPVOID buffer, FPDF_DWORD size)

+{

+	if (!clientData) return -1;

+

+	fseek(((FPDF_FILE*)clientData)->file, (long)offset, SEEK_SET);

+	size_t readSize = fread(buffer, 1, size, ((FPDF_FILE*)clientData)->file);

+	return readSize == size ? 0 : -1;

+}

+

+FPDF_RESULT	Sample_WriteBlock(FPDF_LPVOID clientData, FPDF_DWORD offset, FPDF_LPCVOID buffer, FPDF_DWORD size)

+{

+	if (!clientData) return -1;

+

+	fseek(((FPDF_FILE*)clientData)->file, (long)offset, SEEK_SET);

+	//Write data

+	size_t writeSize = fwrite(buffer, 1, size, ((FPDF_FILE*)clientData)->file);

+	return writeSize == size ? 0 : -1;

+}

+

+FPDF_RESULT	Sample_Flush(FPDF_LPVOID clientData)

+{

+	if (!clientData) return -1;

+

+	//Flush file

+	fflush(((FPDF_FILE*)clientData)->file);

+

+	return 0;

+}

+

+FPDF_RESULT	Sample_Truncate(FPDF_LPVOID clientData, FPDF_DWORD size)

+{

+	return 0;

+}

+

+void	Sample_DisplayCaret(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, FPDF_BOOL bVisible, double left, double top, double right, double bottom)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if (!pView) return;

+

+	HWND hWnd = pView->m_hWnd;

+

+	if (bVisible)

+	{

+		CPoint ltPt;

+		pView->PageToDevice(left, top, ltPt);

+		CPoint rbPt;

+		pView->PageToDevice(right, bottom, rbPt);

+		CRect rcCaret(ltPt, rbPt);

+		

+		::DestroyCaret();

+		::CreateCaret(hWnd, (HBITMAP)0, rcCaret.Width(), rcCaret.Height());

+		::SetCaretPos (rcCaret.left, rcCaret.top);

+		::ShowCaret(hWnd);

+	}

+	else

+	{

+		::DestroyCaret();

+		::HideCaret(hWnd);

+	}

+}

+

+int		Sample_GetCurrentPageIndex(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document)

+{

+	CReaderVCView* pView =(CReaderVCView*)pThis;

+	if (!pView) return -1;

+

+	return pView->GetCurrentPageIndex();

+}

+

+void	Sample_SetCurrentPage(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document, int iCurPage)

+{

+	CReaderVCView* pView = (CReaderVCView*)pThis;

+	if (!pView) return;

+

+	FPDF_DOCUMENT curDoc = pView->GetPDFDoc();

+	if (curDoc != document)

+		return;

+

+	int nPageCount = FPDF_GetPageCount(curDoc);

+	if (nPageCount > iCurPage)

+	{

+		int nCurPageInx = pView->GetCurrentPageIndex();

+		if (nCurPageInx != iCurPage)

+		{

+			pView->GotoPage(nCurPageInx);

+		}

+	}

+}

+

+void	Sample_GotoURL(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document, FPDF_WIDESTRING wsURL)

+{

+	CReaderVCView* pView = (CReaderVCView*)pThis;

+	if (!pView) return;

+

+	wchar_t* pURL = (wchar_t*)wsURL;

+	MessageBoxW(NULL, pURL, NULL, MB_OK);

+}

+

+FPDF_WIDESTRING	Sample_GetURL(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document)

+{

+	CReaderVCView* pView = (CReaderVCView*)pThis;

+	if (!pView) return NULL;

+

+	if (pView->GetPDFDoc() != document)

+		return NULL;

+

+	//not support in this demo

+

+	return NULL;

+}

+

+void Sample_AddDoRecord(struct _FPDF_FORMFILLINFO* pThis, FPDF_DOCUMENT document, FPDF_WIDGET hWidget)

+{

+	//not support

+}

+

+void	Sample_PageEvent(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, FPDF_DWORD eventFlag)

+{

+	//

+}

+

+void	Sample_GetPageViewRect(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, double* left, double* top, double* right, double* bottom)

+{

+	CReaderVCView* pView = (CReaderVCView*)pThis;

+	if (!pView) return;

+

+	if (pView->GetPage() != page)

+		return;

+

+	CRect clientRect;

+	pView->GetClientRect(&clientRect);

+

+	*left = (double)clientRect.left;

+	*right = (double)clientRect.right;

+	*top = (double)clientRect.top;

+	*bottom = (double)clientRect.bottom;

+}

+

+#define	 WM_XFAMENU_COPY	  10000

+

+FPDF_BOOL Sample_PopupMenu(struct _FPDF_FORMFILLINFO* pThis, FPDF_PAGE page, FPDF_WIDGET hWidget, int menuFlag, float x, float y)

+{

+	CReaderVCView* pView = (CReaderVCView*)pThis;

+	if (!pView)

+		return FALSE;

+

+	CMenu menu;

+	menu.CreatePopupMenu();

+

+	int nMenuIndex = 0;

+

+	if (menuFlag & FXFA_MEMU_COPY)

+		menu.InsertMenu(nMenuIndex++, MF_BYPOSITION, WM_XFAMENU_COPY, "Copy");

+	//...

+

+	CPoint pt;

+	pView->PageToDevice(x, y, pt);

+

+	UINT nID = menu.TrackPopupMenu(TPM_RIGHTBUTTON, pt.x, pt.y, pView);

+	switch(nID)

+	{

+	case WM_XFAMENU_COPY:

+		{

+			FPDF_DWORD length = 0;

+			FPDF_Widget_Copy(pView->GetPDFDoc(), hWidget, NULL, &length);

+			if (length > 0)

+			{

+				unsigned short* buffer = (unsigned short*)malloc((length+1)*sizeof(unsigned short));

+				memset(buffer, 0, (length+1)*sizeof(unsigned short));

+				FPDF_Widget_Copy(pView->GetPDFDoc(), hWidget, buffer, &length);

+				free(buffer);

+			}

+		}

+		break;

+	}

+

+	menu.DestroyMenu();

+

+	return TRUE;

+}

+

+FPDF_FILEHANDLER* Sample_OpenFile(struct _FPDF_FORMFILLINFO* pThis, int fileFlag, FPDF_WIDESTRING wsURL)

+{

+	char* pszURL;

+	CString strURL;

+	if (wsURL == NULL) {

+		if (fileFlag == FXFA_FILE_XDP)

+			strURL = "C://temp.xdp";

+		else if(fileFlag == FXFA_FILE_XML)

+			strURL = "C://temp.xml";

+	}

+	else {

+		int iSize;

+		iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsURL, -1, NULL, 0, NULL, NULL);

+		pszURL = (char*)malloc((iSize+1));

+		WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsURL, -1, pszURL, iSize, NULL, NULL);

+		CString str(pszURL);

+		strURL = str;

+	}

+	

+

+	FILE* file = fopen(strURL, "r");

+	FPDF_FILE* pFileHander = new FPDF_FILE;

+	pFileHander->file = file;

+	pFileHander->fileHandler.clientData = pFileHander;

+	pFileHander->fileHandler.Flush = Sample_Flush;

+	pFileHander->fileHandler.GetSize = Sample_GetSize;

+	pFileHander->fileHandler.ReadBlock = Sample_ReadBlock;

+	pFileHander->fileHandler.Release = Sample_Release;

+	pFileHander->fileHandler.Truncate = Sample_Truncate;

+	pFileHander->fileHandler.WriteBlock = Sample_WriteBlock;

+

+	free(pszURL);

+	return &pFileHander->fileHandler;

+}

+

+FPDF_BOOL Sample_GetFilePath(struct _FPDF_FORMFILLINFO* pThis, FPDF_FILEHANDLER* pFileHandler, FPDF_BSTR* path)

+{

+	CReaderVCView* pView = (CReaderVCView*)pThis;

+	if (!pView)

+		return NULL;

+

+	CString filePath = pView->GetFilePath();

+	FPDF_BStr_Set(path, filePath.GetBuffer(filePath.GetLength()), filePath.GetLength());

+

+	return TRUE;

+}

+

+void	Sample_EmailTo(struct _FPDF_FORMFILLINFO* pThis, FPDF_FILEHANDLER* fileHandler, FPDF_WIDESTRING emailTo)

+{

+	MessageBoxW(NULL, (wchar_t*)emailTo, L"Sample_email", MB_OK);

+}

+

+void	Sample_UploadTo(struct _FPDF_FORMFILLINFO* pThis, FPDF_FILEHANDLER* fileHandler, FPDF_WIDESTRING uploadTo)

+{

+	int iSize;

+	char* pszURL;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)uploadTo, -1, NULL, 0, NULL, NULL);

+	pszURL = (char*)malloc((iSize+1));

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)uploadTo, -1, pszURL, iSize, NULL, NULL);

+	CString strPath(pszURL);

+

+	CString strUploadPath = "C://test";

+	int pos = strPath.ReverseFind('.');

+	if (pos != -1){

+		CString suffix = strPath.Right(strPath.GetLength()-pos);

+		strUploadPath += suffix;

+	}

+

+	FILE* file = fopen(strUploadPath, "r");

+	if (file) {

+		int size = fileHandler->GetSize(fileHandler->clientData);

+		BYTE* buffer = (BYTE*)malloc(size);

+		fileHandler->ReadBlock(fileHandler->clientData, 0, buffer, size);

+		fwrite(buffer, size, 1, file);

+		fflush(file);

+		fclose(file);

+		free(buffer);

+	}

+

+	free(pszURL);

+}

+

+int		Sample_GetAppName(struct _FPDF_FORMFILLINFO* pThis, void* appName, int length)

+{

+	if(appName == NULL || length <= 0)

+	{

+		CString name = AfxGetAppName();

+		return name.GetLength();

+	}	

+	else

+	{

+		CString name = AfxGetAppName();

+		int len = name.GetLength();

+		if(length > len)

+			length = len;

+		memcpy(appName, name.GetBuffer(name.GetLength()), length);

+		return length;

+	}

+}

+

+int		Sample_GetPlatform(struct _FPDF_FORMFILLINFO* pThis, void* platform, int length)

+{

+	if(platform == NULL || length <= 0)

+	{

+		return 3;

+	}	

+	else

+	{

+		if(length > 3)

+			length = 3;

+		memcpy(platform, "win", length);

+		return length;

+	}

+}

+

+int		Sample_GetDocumentCount(struct _FPDF_FORMFILLINFO* pThis)

+{

+	return 1;

+}

+

+int		Sample_GetCurDocumentIndex(struct _FPDF_FORMFILLINFO* pThis)

+{

+	return 0;

+}

+

+FPDF_LPFILEHANDLER	Sample_DownloadFromURL(struct _FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING URL)

+{

+	int iSize;

+	char* pszURL;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)URL, -1, NULL, 0, NULL, NULL);

+	pszURL = (char*)malloc((iSize+1));

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)URL, -1, pszURL, iSize, NULL, NULL);

+	CString strURL(pszURL);

+

+	CString bsLocal = strURL;

+	CReaderVCView::CreateLocalPath(bsLocal);

+

+	if (strURL.Left(7) == "http://")

+	{

+		CInternetSession sess;

+		CHttpFile *pFile = (CHttpFile*)sess.OpenURL(strURL);

+		int iLength = pFile->GetLength();

+		if (pFile == NULL || iLength < 1) return NULL;

+

+		FILE *pImageFile = fopen(bsLocal, "wb");

+

+		BYTE* pContent = new BYTE[iLength];

+		memset(pContent, 0, iLength);

+		int iRead = pFile->Read(pContent, iLength);

+

+		fwrite(pContent, 1, iLength, pImageFile);

+		free(pContent);

+		fflush(pImageFile);

+		fclose(pImageFile);

+

+		pFile->Close();

+		delete pFile;

+		sess.Close();

+	}

+	else if (strURL.Left(6) == "ftp://")

+	{

+		CInternetSession sess;

+		CFtpConnection* pConnect = sess.GetFtpConnection(bsLocal, "NULL", "NULL"); 

+		CInternetFile* pFile = pConnect->OpenFile(bsLocal);

+

+		int iLength = pFile->GetLength();

+		if (pFile == NULL || iLength < 1) return NULL;

+		FILE *pImageFile = fopen(bsLocal, "wb");

+

+		BYTE* pContent = new BYTE[iLength];

+		memset(pContent, 0, iLength);

+		int iRead = pFile->Read(pContent, iLength);

+

+		fwrite(pContent, 1, iLength, pImageFile);

+		free(pContent);

+		fflush(pImageFile);

+		fclose(pImageFile);

+

+		pFile->Close();

+		delete pFile;

+		sess.Close();

+	}	

+	

+	free(pszURL);

+	

+	FPDF_FILE* fileWrap = new FPDF_FILE;

+	FILE* file = fopen(bsLocal, "r");

+	fileWrap->file = file;

+	fileWrap->fileHandler.clientData = fileWrap;

+	fileWrap->fileHandler.ReadBlock = Sample_ReadBlock;

+	fileWrap->fileHandler.GetSize = Sample_GetSize;

+	fileWrap->fileHandler.Flush = Sample_Flush;

+	fileWrap->fileHandler.Release = Sample_Release;

+	fileWrap->fileHandler.Truncate = Sample_Truncate;

+	fileWrap->fileHandler.WriteBlock = Sample_WriteBlock;

+

+	return &fileWrap->fileHandler;

+}

+

+FPDF_BOOL	Sample_PostRequestURL(struct _FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING wsURL, FPDF_WIDESTRING wsData, FPDF_WIDESTRING wsContentType, FPDF_WIDESTRING wsEncode, FPDF_WIDESTRING wsHeader, FPDF_BSTR* respone)

+{

+	int iSize;

+	char* pszURL;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsURL, -1, NULL, 0, NULL, NULL);

+	pszURL = (char*)malloc((iSize+1));

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsURL, -1, pszURL, iSize, NULL, NULL);

+	CString csURL(pszURL);

+

+	char* pszData;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsData, -1, NULL, 0, NULL, NULL);

+	pszData = (char*)malloc(iSize+1);

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsData, -1, pszData, iSize, NULL, NULL);

+	CString csData(pszData);

+	

+	char* pszContentType;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsContentType, -1, NULL, 0, NULL, NULL);

+	pszContentType = (char*)malloc(iSize+1);

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsContentType, -1, pszContentType, iSize, NULL, NULL);

+	CString csContentType(pszContentType);

+	

+	char* pszHeader;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsHeader, -1, NULL, 0, NULL, NULL);

+	pszHeader = (char*)malloc(iSize+1);

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsHeader, -1, pszHeader, iSize, NULL, NULL);

+	CString csHeader(pszHeader);

+

+	CString csApp = AfxGetAppName();

+	csApp += L"/1.0";

+	BOOL bRet = FALSE;

+	DWORD dwServiceType = 0, dwFlags = ICU_NO_META;

+	CString csServer, sObject, csUserName, csPassword;

+	INTERNET_PORT nPort = 0;

+

+	bRet = AfxParseURLEx(csURL, dwServiceType, csServer, sObject, nPort, csUserName, csPassword, dwFlags);

+	if (!bRet)

+		return bRet;

+

+	if (dwServiceType != AFX_INET_SERVICE_HTTP && dwServiceType != AFX_INET_SERVICE_HTTPS)

+		return bRet;

+

+	CString csObject = sObject;

+	CString csResponse;

+	bRet = CReaderVCView::HttpDataPost(csData, csApp, csObject, csServer, csUserName, csPassword, nPort,

+		dwServiceType == AFX_INET_SERVICE_HTTPS, csContentType, csHeader, csResponse);

+

+	FPDF_BStr_Init(respone);

+	FPDF_BStr_Set(respone, (FPDF_LPCSTR)csResponse.GetBuffer(csResponse.GetLength()), csResponse.GetLength());

+

+	free(pszURL);

+	free(pszData);

+	free(pszContentType);

+	free(pszHeader);

+

+	return true;

+}

+

+FPDF_BOOL	Sample_PutRequestURL(struct _FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING wsURL, FPDF_WIDESTRING wsData, FPDF_WIDESTRING wsEncode)

+{

+	int iSize;

+	char* pszURL;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsURL, -1, NULL, 0, NULL, NULL);

+	pszURL = (char*)malloc((iSize+1));

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsURL, -1, pszURL, iSize, NULL, NULL);

+	CString csURL(pszURL);

+

+	char* pszData;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsData, -1, NULL, 0, NULL, NULL);

+	pszData = (char*)malloc((iSize+1));

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsData, -1, pszData, iSize, NULL, NULL);

+	CString csData(pszData);

+

+	CString csApp = AfxGetAppName();

+	csApp += L"/1.0";

+	BOOL bRet = FALSE;

+	DWORD dwServiceType = 0, dwFlags = ICU_NO_META;

+	CString csServer, sObject, csUserName, csPassword;

+	INTERNET_PORT nPort = 0;

+

+	bRet = AfxParseURLEx(csURL, dwServiceType, csServer, sObject, nPort, csUserName, csPassword, dwFlags);

+	if (!bRet)

+		return bRet;

+

+	if (dwServiceType != AFX_INET_SERVICE_HTTP && dwServiceType != AFX_INET_SERVICE_HTTPS)

+		return bRet;

+

+	CString csObject = sObject;

+

+	bRet = CReaderVCView::HttpDataPut(csData, csApp, csObject, csServer, csUserName, csPassword, nPort, dwServiceType == AFX_INET_SERVICE_HTTPS);

+	

+	free(pszData);

+	free(pszURL);

+	return TRUE;

+}

+

+FPDF_BOOL	Sample_ShowFileDialog(struct _FPDF_FORMFILLINFO* pThis, FPDF_WIDESTRING wsTitle, FPDF_WIDESTRING wsFilter, FPDF_BOOL isOpen, FPDF_STRINGHANDLE pathArr)

+{

+	int iSize;

+	char* pszFilter;

+	iSize = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsFilter, -1, NULL, 0, NULL, NULL);

+	pszFilter = (char*)malloc((iSize+1));

+	WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wsFilter, -1, pszFilter, iSize, NULL, NULL);

+

+	CFileDialog fileOpen(isOpen, NULL,NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST, pszFilter);

+	//	fileOpen.m_ofn.Flags|=OFN_ENABLEHOOK|OFN_ALLOWMULTISELECT;

+	if(fileOpen.DoModal()==IDCANCEL) 

+	{ 

+		return FALSE;	

+	}

+	

+	POSITION pos;	

+	pos=fileOpen.GetStartPosition(); 

+	CString csFile;

+	while(pos!=NULL) 

+	{ 

+		csFile=fileOpen.GetNextPathName(pos); 

+		FPDF_StringHandleAddString(pathArr, csFile.GetBuffer(csFile.GetLength()), csFile.GetLength());		

+	}

+

+	free(pszFilter);

+	return TRUE;

+}

+

+FPDF_SYSTEMTIME CReaderVCView::GetLocalTimeImpl()

+{

+	FPDF_SYSTEMTIME sys;

+	time_t curTime;

+	time(&curTime);

+	tm* pTm = localtime(&curTime);

+	if(pTm)

+	{

+		sys.wDay = pTm->tm_mday;

+		sys.wDayOfWeek= pTm->tm_wday;

+		sys.wHour = pTm->tm_hour;

+		sys.wMilliseconds = 0;

+		sys.wMinute = pTm->tm_min;

+		sys.wMonth = pTm->tm_mon;

+		sys.wSecond = pTm->tm_sec;

+		sys.wYear = pTm->tm_year + 1900;

+	}

+	

+	return sys;

+}

+

+int CReaderVCView::GetRotationImpl(FPDF_PAGE page)

+{

+	return m_nRotateFlag;

+}

+

+FPDF_PAGE CReaderVCView::GetPageImpl(FPDF_DOCUMENT document,int nPageIndex)

+{

+	FPDF_PAGE page = NULL;

+	m_pageMap.Lookup(nPageIndex, page);

+	if(page)

+		return page;

+	page = FPDF_LoadPage(document, nPageIndex);

+	FORM_OnAfterLoadPage(page, m_pApp);

+	m_pageMap.SetAt(nPageIndex, page);

+	return page;

+}

+

+FPDF_PAGE CReaderVCView::GetCurrentPageImpl(FPDF_DOCUMENT document)

+{

+	return m_pPage;

+}

+

+bool CReaderVCView::IsALTKeyDownImpl()

+{

+	return GetKeyState(VK_MENU) < 0;

+}

+bool CReaderVCView::IsINSERTKeyDownImpl()

+{

+	return GetKeyState(VK_INSERT) & 0x01;

+}

+bool CReaderVCView::IsSHIFTKeyDownImpl()

+{

+	return !((GetKeyState(VK_SHIFT)&0x8000) == 0);

+}

+bool CReaderVCView::IsCTRLKeyDownImpl()

+{

+	return GetKeyState(VK_CONTROL) < 0;

+}

+

+void CReaderVCView::OnChangeImpl()

+{

+

+}

+

+CString CReaderVCView::GetFilePath()

+{

+	CReaderVCDoc* pDoc = GetDocument();

+	if(pDoc)

+	{

+		return pDoc->m_strPDFName;

+	}

+	return "";

+}

+

+BOOL CReaderVCView::SubmitFormImpl(void* pBuffer, int nLength, CString strURL)

+{

+	CString tempFDFFile = "D://1.fdf";

+

+	if (pBuffer == NULL || nLength <= 0)

+	{

+		return FALSE;

+	}

+

+	CFile file;

+	if (file.Open(tempFDFFile, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary))

+	{

+		file.Write(pBuffer, nLength);

+		file.Close();

+	}

+

+	return TRUE;

+}

+

+int Sample_appResponse(struct _IPDF_JsPlatform* pThis, FPDF_WIDESTRING Question, FPDF_WIDESTRING Title, 

+					   FPDF_WIDESTRING Default, FPDF_WIDESTRING cLabel, FPDF_BOOL bPassword, void* response, int length)

+{

+	CReaderVCView* pView = (CReaderVCView*)pThis->m_pFormfillinfo;

+	FPDF_WIDESTRING wsResponse;

+

+	if (pView->m_pwsResponse && response != NULL)

+	{

+		wsResponse = (FPDF_WIDESTRING)pView->m_pwsResponse;

+		length = wcslen((const wchar_t*)wsResponse);

+		memcpy(response, wsResponse, length*sizeof(wchar_t));

+		pView->m_pwsResponse = NULL;

+	}	

+	else

+	{

+		CJS_ResponseDlg dlg;

+		dlg.SetTitle(Title);

+		dlg.SetDefault(Default);

+		dlg.SetLabel(cLabel);

+		dlg.SetQuestion(Question);

+		dlg.SetIsVisible(bPassword);

+		int iRet = dlg.DoModal();		

+		

+		if (iRet == 1)

+		{

+			wsResponse = dlg.GetResponse();

+			length = wcslen((const wchar_t*)wsResponse);

+			pView->m_pwsResponse = new wchar_t[length+1];

+			memset(pView->m_pwsResponse, 0, length*sizeof(wchar_t));

+			memcpy(pView->m_pwsResponse, wsResponse, length*sizeof(wchar_t));

+			pView->m_pwsResponse[length] = L'\0';

+		}

+	}

+	

+	return length*sizeof(wchar_t);

+}

+

+int Sample_appalert(struct _IPDF_JsPlatform* pThis, FPDF_WIDESTRING Msg, FPDF_WIDESTRING Title, int Type, int Icon)

+{

+	int nRet = 0;

+	if(pThis && pThis->m_pFormfillinfo)

+	{

+		CReaderVCView* pView = (CReaderVCView*)pThis->m_pFormfillinfo;

+		int msgType = MB_OK;

+		switch(Type)

+		{

+	

+		case 1:

+			msgType = MB_OKCANCEL;

+			break;

+		case 2:

+			msgType = MB_YESNO;

+			break;

+		case 3:

+			msgType = MB_YESNOCANCEL;

+			break;	

+		case 0:

+		default:

+			break;

+		}

+		nRet = MessageBoxW(pView->m_hWnd, (const wchar_t*)Msg, (const wchar_t*)Title, msgType);

+		switch(nRet)

+		{

+		case IDOK:

+			return 1;

+		case IDCANCEL:

+			return 2;

+		case IDNO:

+			return 3;

+		case IDYES:

+			return 4;

+		}

+		return nRet;

+	}

+	return nRet;

+}

+

+void Sample_appbeep(struct _IPDF_JsPlatform* pThis, int nType)

+{

+	MessageBeep(nType);

+	//AfxMessageBox("aaaa");

+}

+

+

+CString userSelFilePath;

+int  Sample_fieldBrowse(struct _IPDF_JsPlatform* pThis,void* filePath, int length)

+{

+	if(userSelFilePath.IsEmpty())

+	{

+		CFileDialog fd(FALSE, "fdf");

+		if(fd.DoModal() == IDOK)

+		{

+			userSelFilePath = fd.GetPathName();

+			

+			if(filePath == NULL || length == 0)

+				return userSelFilePath.GetLength() + 1;

+			else

+				return 0;

+		}

+		else

+			return 0;

+	}	

+	else

+	{

+		int nLen = userSelFilePath.GetLength()+1;

+		if(length > nLen)

+			length = nLen;

+		memcpy(filePath, userSelFilePath.GetBuffer(length), length);

+		userSelFilePath.ReleaseBuffer();

+		userSelFilePath = "";

+		return length;

+	}

+}

+int Sample_docGetFilePath(struct _IPDF_JsPlatform* pThis, void* filePath, int length)

+{

+	if(pThis && pThis->m_pFormfillinfo)

+	{

+		CReaderVCView* pView = (CReaderVCView*)pThis->m_pFormfillinfo;

+		CString csFilePath = pView->GetFilePath();

+

+		int nbufflen = csFilePath.GetLength() + 1;

+		if(filePath == NULL || length == 0)

+			return nbufflen;

+

+		if(length > nbufflen)

+			length = nbufflen;

+		memcpy(filePath, csFilePath.GetBuffer(length), length);

+		csFilePath.ReleaseBuffer();

+

+		return length;

+

+	}

+	return 0;

+}

+

+void Sample_docSubmitForm(struct _IPDF_JsPlatform* pThis,void* formData, int length, FPDF_WIDESTRING URL)

+{

+	if(pThis && pThis->m_pFormfillinfo)

+	{

+		CReaderVCView *pView = (CReaderVCView*)pThis->m_pFormfillinfo;

+		if (pView)

+		{

+			pView->SubmitFormImpl(formData, length, "");

+		}

+	}	

+}

+

+void Sample_gotoPage(struct _IPDF_JsPlatform* pThis, int nPageNum)

+{

+	if(pThis && pThis->m_pFormfillinfo)

+	{

+		CReaderVCView *pView = (CReaderVCView*)pThis->m_pFormfillinfo;

+		if (pView)

+		{

+			pView->GotoPage(nPageNum);

+		}

+	}	

+}

+

+CReaderVCView::CReaderVCView()

+{

+	// TODO: add construction code here

+	m_pFram = NULL;

+	m_pExportPageDlg = 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;

+

+	//for search text

+	m_pTextPage = NULL;

+	m_FindInfo.m_strFind = _T("");

+	m_FindInfo.m_nFlag = -1;

+	m_FindInfo.m_nDirection = -1;

+	m_FindInfo.m_nStartPageIndex = -1;

+	m_FindInfo.m_nStartCharIndex = -1;

+	m_FindInfo.m_bFirst = TRUE;

+	m_FindInfo.m_pCurFindBuf = NULL;

+	m_pSCHHandle = NULL;

+

+	m_rtFind = NULL;

+	m_nRectNum = 0;

+	

+	//for select text

+	m_bSelect = FALSE;

+	m_bHand = TRUE;

+	m_bSnap = FALSE;

+	m_bHasChar = FALSE;

+	

+	m_ptLBDown.x = m_ptLBDown.y = 0;

+	m_ptLBUp.x = m_ptLBUp.y = 0;

+	m_ptOld.x = m_ptOld.y = 0;

+

+	m_nStartIndex = m_nEndIndex = m_nOldIndex = -1;

+	m_rtArray.RemoveAll();

+	m_rtOld.left = m_rtOld.right = m_rtOld.bottom = m_rtOld.top = 0;

+

+	m_nPosH = m_nPosV = -1;

+

+	// for links

+	m_pLink = NULL;

+	m_bBookmark = FALSE;

+

+	m_bmp = NULL;

+	m_pwsResponse = NULL;

+

+	this->FFI_Invalidate = Sample_Invalidate;

+	this->Release= Sample_Release;

+	this->FFI_SetTimer = Sample_SetTimer;

+	this->FFI_KillTimer = Sample_KillTimer;

+	this->FFI_GetLocalTime = Sample_GetLocalTime;

+	this->FFI_SetCursor = Sample_SetCursor;

+	this->FFI_OnChange = Sample_OnChange;

+	this->FFI_GetPage = Sample_GetPage;

+	this->FFI_GetCurrentPage = Sample_GetCurrentPage;

+	this->FFI_GetRotation = Sample_GetRotation;

+	this->FFI_OutputSelectedRect = Sample_OutputSelectedRect;

+	this->FFI_ExecuteNamedAction = Sample_ExecuteNamedAction;

+	this->FFI_OutputSelectedRect  = NULL;

+	this->FFI_SetTextFieldFocus = NULL;

+	this->FFI_DoGoToAction = NULL;

+	this->FFI_DoURIAction = NULL;

+	this->FFI_DisplayCaret = Sample_DisplayCaret;

+	this->FFI_GetCurrentPageIndex = Sample_GetCurrentPageIndex;

+	this->FFI_SetCurrentPage = Sample_SetCurrentPage;

+	this->FFI_GotoURL = Sample_GotoURL;

+	this->FFI_GetPageViewRect = Sample_GetPageViewRect;

+	this->FFI_PopupMenu = Sample_PopupMenu;

+	this->FFI_OpenFile = Sample_OpenFile;

+	this->FFI_GetFilePath = Sample_GetFilePath;

+	this->FFI_EmailTo = Sample_EmailTo;

+	this->FFI_UploadTo = Sample_UploadTo;

+	this->FFI_GetPlatform = Sample_GetPlatform;

+	this->FFI_GetDocumentCount = Sample_GetDocumentCount;

+	this->FFI_GetCurDocumentIndex = Sample_GetCurDocumentIndex;

+	this->FFI_DownloadFromURL = Sample_DownloadFromURL;

+	this->FFI_PostRequestURL = Sample_PostRequestURL;

+	this->FFI_PutRequestURL = Sample_PutRequestURL;

+	this->FFI_ShowFileDialog = Sample_ShowFileDialog;	

+	this->version = 1;

+	

+	this->m_pJsPlatform = NULL;

+  	this->m_pJsPlatform = new IPDF_JSPLATFORM;

+	memset(m_pJsPlatform, 0, sizeof(IPDF_JSPLATFORM));

+  	this->m_pJsPlatform->app_alert = Sample_appalert;

+	this->m_pJsPlatform->app_response = Sample_appResponse;

+ 	this->m_pJsPlatform->app_beep = Sample_appbeep;

+  	this->m_pJsPlatform->Field_browse =Sample_fieldBrowse;

+  	this->m_pJsPlatform->Doc_getFilePath = Sample_docGetFilePath;

+	this->m_pJsPlatform->Doc_submitForm = Sample_docSubmitForm;

+	this->m_pJsPlatform->Doc_gotoPage = Sample_gotoPage;

+  	this->m_pJsPlatform->m_pFormfillinfo = this;

+

+	m_pApp = NULL;

+}

+

+

+CReaderVCView::~CReaderVCView()

+{

+

+//	FPDF_DestroyApp(m_App);

+

+	if(m_pTextPage != NULL)

+	{

+		FPDFText_ClosePage(m_pTextPage);

+		m_pTextPage = NULL;

+	}

+	if (m_pLink != NULL)

+	{

+		FPDFLink_CloseWebLinks(m_pLink);

+		m_pLink = NULL;

+	}

+

+	POSITION pos = m_pageMap.GetStartPosition();

+	while(pos)

+	{

+		int nIndex = 0;

+		FPDF_PAGE page = NULL;

+		m_pageMap.GetNextAssoc(pos, nIndex, page);

+

+		if (page)

+		{

+			FORM_OnBeforeClosePage(page, m_pApp);

+			FPDF_ClosePage(page);

+		}

+	}

+	m_pPage = NULL;

+

+	if (m_pDoc != NULL)

+	{

+		//Should strictly follow the reverse order of initialization .

+		FORM_DoDocumentAAction(m_pApp, FPDFDOC_AACTION_WC);

+		if(m_pApp)

+			FPDFDOC_ExitFormFillEnviroument(m_pApp);

+		FPDF_CloseDocument(m_pDoc);

+		m_pDoc = NULL;

+	}

+	if (m_FindInfo.m_pCurFindBuf != NULL)

+	{

+		delete []m_FindInfo.m_pCurFindBuf;

+		m_FindInfo.m_pCurFindBuf = NULL;

+	}

+	if (m_rtFind != NULL)

+	{

+		delete m_rtFind;

+		m_rtFind = NULL;

+	}

+	if(m_bmp != NULL)

+	{

+		FPDFBitmap_Destroy(m_bmp);

+	}

+

+	if (m_pwsResponse)

+	{

+		delete m_pwsResponse;

+		m_pwsResponse = NULL;

+	}

+

+	if(this->m_pJsPlatform)

+		delete m_pJsPlatform;

+

+	m_mapTimerFuns.RemoveAll();

+//	m_formFiledInfo.Release();

+//	}

+//	m_rtArray.RemoveAll();

+}

+

+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);

+	DrawAllRect(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, CPoint pos)

+{

+	if(NULL == doc) return FALSE;

+	if(nIndex < 0) nIndex = 0;

+	if(nIndex > m_nTotalPage) nIndex = m_nTotalPage;

+

+	FORM_DoPageAAction(m_pPage, m_pApp, FPDFPAGE_AACTION_CLOSE);

+

+	m_pPage = NULL;

+	m_pageMap.Lookup(nIndex, m_pPage);

+	if(!m_pPage)

+	{

+		m_pPage = FPDF_LoadPage(doc, nIndex);

+		FORM_OnAfterLoadPage(m_pPage, m_pApp);

+		m_pageMap.SetAt(nIndex, m_pPage);	

+	}

+	if(NULL == m_pPage) return FALSE;

+

+	FORM_DoPageAAction(m_pPage, m_pApp, FPDFPAGE_AACTION_OPEN);

+

+	m_nPageIndex = nIndex;

+    SetPageMetrics(m_pPage);

+

+	if (m_pTextPage != NULL)

+	{

+		FPDFText_ClosePage(m_pTextPage);

+		m_pTextPage = NULL;	

+	}

+	m_pTextPage = FPDFText_LoadPage(m_pPage);

+

+

+	CChildFrame *pParent = (CChildFrame *)this->GetParentFrame();

+	if (pParent != NULL)

+	{

+		pParent->SetActiveView(this);

+		SyncScroll();	

+	}

+	

+	if(pos.x !=0 && pos.y != 0)

+	{

+		FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(m_nActualSizeX * m_dbScaleFactor),

+			(int)(m_nActualSizeY * m_dbScaleFactor), m_nRotateFlag, pos.x, pos.y, &m_nStartX, &m_nStartY);			

+		m_nStartX = -m_nStartX + 20;

+		m_nStartY = -m_nStartY + 20;

+		

+		int nSizeX = 0; 

+		int nSizeY = 0;

+		if (1 == m_nRotateFlag || 3 == m_nRotateFlag)

+		{

+			nSizeX = m_nActualSizeY;

+			nSizeY = m_nActualSizeX;

+		}

+		else

+		{

+			nSizeX = m_nActualSizeX;

+			nSizeY = m_nActualSizeY;

+		}

+		SCROLLINFO scrinfo;

+		GetScrollInfo(SB_VERT, &scrinfo);                                         

+		scrinfo.nMin = 0;                                                         

+		scrinfo.nMax =(int) (nSizeY * m_dbScaleFactor + abs(m_nStartY));                                             

+		SetScrollInfo(SB_VERT, &scrinfo);  

+		SetScrollPos(SB_VERT, abs(m_nStartY), TRUE);

+

+		GetScrollInfo(SB_HORZ, &scrinfo);                                         

+		scrinfo.nMin = 0;                                                         

+		scrinfo.nMax = (int)(nSizeX * m_dbScaleFactor + abs(m_nStartX));                                             

+		SetScrollInfo(SB_HORZ, &scrinfo);  

+		SetScrollPos(SB_HORZ, abs(m_nStartX), TRUE);

+	}

+	this->Invalidate(TRUE);

+//	FPDFApp_SetPage(m_App, m_pPage);

+	return TRUE;

+

+}

+

+

+void CReaderVCView::InvalidateImpl(FPDF_PAGE page, double left, double top, double right, double bottom)

+{

+	int device_left, device_top, device_right, device_bottom;

+

+	int nActualRangeX = 0;

+	int nActualRangeY = 0;

+	if ( m_nRotateFlag % 2 == 0 )

+	{

+		nActualRangeX = m_nActualSizeX;

+		nActualRangeY = m_nActualSizeY;

+	}else{

+		nActualRangeX = m_nActualSizeY;

+		nActualRangeY = m_nActualSizeX;

+	}

+

+	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, left, top, &device_left, &device_top);

+

+	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, right, bottom, &device_right, &device_bottom);

+

+	CRect rc(device_left,device_top, device_right, device_bottom);

+// 	TRACE("left = %d\r\n", device_left);

+// 		TRACE("top = %d\r\n", device_top);

+// 			TRACE("right = %d\r\n", device_right);

+// 				TRACE("bottom = %d\r\n", device_bottom);

+	if(device_right-device_left>5)

+	TRACE("left=%d,top=%d,right=%d,bottom=%d\r\n",device_left,device_top,device_right,device_bottom);

+	::InvalidateRect(m_hWnd, rc, FALSE);

+}

+

+void CReaderVCView::SetCaretImpl(FPDF_PAGE page,double page_x, double page_y, int nWidth, int nHeight)

+{

+

+}

+

+void CReaderVCView::ReleaseImpl()

+{

+

+}

+CMap<int, int,TimerCallback, TimerCallback> CReaderVCView::m_mapTimerFuns;

+int CReaderVCView::SetTimerImpl(int uElapse, TimerCallback lpTimerFunc)

+{

+	int nTimeID =  ::SetTimer(NULL, 0, uElapse, TimerProc);	

+	m_mapTimerFuns.SetAt(nTimeID, lpTimerFunc);

+	return nTimeID;

+}

+

+void CReaderVCView::KillTimerImpl(int nID)

+{

+	::KillTimer(NULL, nID);

+	m_mapTimerFuns.RemoveKey(nID);

+}

+

+void CReaderVCView::SetCurorImpl(int nCursorType)

+{

+	HCURSOR hcur = LoadCursor(NULL, IDC_UPARROW);

+	switch(nCursorType)

+	{

+	 	case	FXCT_ARROW:

+	 	case	FXCT_NESW:		

+	 	case	FXCT_NWSE:		

+	 	case	FXCT_VBEAM:		

+	 	case	FXCT_HBEAM:		

+	 	case    FXCT_HAND:

+	 	//	::SetCursor(hcur);

+	 	break;

+	}

+}

+

+void CReaderVCView::PageToDeviceImpl(FPDF_PAGE page,double page_x,double page_y, int* device_x, int* device_y)

+{

+	int nActualRangeX = 0;

+	int nActualRangeY = 0;

+	if ( m_nRotateFlag % 2 == 0 )

+	{

+		nActualRangeX = m_nActualSizeX;

+		nActualRangeY = m_nActualSizeY;

+	}else{

+		nActualRangeX = m_nActualSizeY;

+		nActualRangeY = m_nActualSizeX;

+	}

+ 	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+				(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, page_x, page_y,device_x, device_y);

+}

+

+void CReaderVCView::DeviceToPageImpl(FPDF_PAGE page,int device_x, int device_y, double* page_x, double* page_y)

+{

+	int nActualRangeX = 0;

+	int nActualRangeY = 0;

+	if ( m_nRotateFlag % 2 == 0 )

+	{

+		nActualRangeX = m_nActualSizeX;

+		nActualRangeY = m_nActualSizeY;

+	}else{

+		nActualRangeX = m_nActualSizeY;

+		nActualRangeY = m_nActualSizeX;

+	}

+	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, device_x, device_y, page_x, page_y);

+

+}

+

+void CReaderVCView::SetPageMetrics(FPDF_PAGE pPage)

+{

+	m_nStartX = 10;

+	m_nStartY = 10;

+	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 = (int)(m_dbPageWidth / 72 * ix + 0.5f);//convert pdf coordinates to device

+	m_nActualSizeY = (int)(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;

+	}

+	

+	int nShowSizeX = (int)(nSizeX * m_dbScaleFactor + m_nStartX);

+	int nShowSizeY = (int)(nSizeY * m_dbScaleFactor + m_nStartY);

+	

+

+	CRect rc; 

+	pDC->GetClipBox(&rc);

+		FPDF_BITMAP bmptemp = FPDFBitmap_Create(rc.Width(), rc.Height(), 0);

+		int nClientWidth = FPDFBitmap_GetWidth(bmptemp);

+		int nClientHeight = FPDFBitmap_GetHeight(bmptemp);

+		

+		

+		FPDFBitmap_FillRect(bmptemp, 0, 0, nClientWidth, nClientHeight, 255,255,255, 0);

+		FPDF_RenderPageBitmap(bmptemp, m_pPage, m_nStartX-rc.left, m_nStartY-rc.top, (int)(nSizeX * m_dbScaleFactor), (int)(nSizeY * m_dbScaleFactor), nRotate, 

+			FPDF_LCD_TEXT | FPDF_NO_NATIVETEXT);

+		FPDF_FFLDraw(m_pApp, bmptemp, m_pPage, m_nStartX-rc.left, m_nStartY-rc.top, (int)(nSizeX * m_dbScaleFactor), (int)(nSizeY * m_dbScaleFactor), nRotate, 

+			FPDF_ANNOT | FPDF_LCD_TEXT | FPDF_NO_NATIVETEXT);

+		

+		// 	m_pPage2 = FPDF_LoadPage(m_pDoc, 2);

+		// 	FPDF_RenderPageBitmap(m_bmp, m_pPage2, m_nStartX+500, m_nStartY, (int)(nSizeX * m_dbScaleFactor), (int)(nSizeY * m_dbScaleFactor), nRotate, 

+		// 		FPDF_LCD_TEXT | FPDF_NO_NATIVETEXT);

+		// 	FPDF_FFLDraw(m_pApp, m_bmp, m_pPage2, m_nStartX+500, m_nStartY, (int)(nSizeX * m_dbScaleFactor), (int)(nSizeY * m_dbScaleFactor), nRotate, 

+		//  		FPDF_ANNOT | FPDF_LCD_TEXT | FPDF_NO_NATIVETEXT);

+		

+		int t = FPDFBitmap_GetStride(bmptemp);

+		int bufsize=FPDFBitmap_GetStride(bmptemp)*nClientHeight;

+		void* bmpbuf=FPDFBitmap_GetBuffer(bmptemp);

+		CDC MemDC;

+		

+		CBitmap winbmp;

+		MemDC.CreateCompatibleDC(pDC);

+		if((HBITMAP)winbmp != NULL)

+			winbmp.DeleteObject();

+		if(HBITMAP(winbmp) == NULL)

+		{

+			winbmp.CreateCompatibleBitmap(pDC,nClientWidth,nClientHeight);

+			winbmp.SetBitmapBits(bufsize,bmpbuf);

+		}

+		

+		MemDC.SelectObject(&winbmp); 

+		

+		pDC->BitBlt(rc.left , rc.top , nClientWidth, nClientHeight, &MemDC,0,0,SRCCOPY);

+		MemDC.DeleteDC();    

+		

+		FPDFBitmap_Destroy(bmptemp);

+	

+	

+	int size = m_SelectArray.GetSize();

+	for(int i=0; i<size; i++)

+	{

+		

+		

+		CRect rc = m_SelectArray.GetAt(i);

+		

+		CDC memdc;

+		CBitmap bmp,*pOldBitmap; 

+		memdc.CreateCompatibleDC(pDC); 

+		

+		bmp.CreateCompatibleBitmap(pDC,rc.Width(),rc.Height());

+		

+		pOldBitmap = memdc.SelectObject(&bmp);

+		

+		memdc.FillSolidRect(0,0,rc.Width(),rc.Height(),RGB(0,100,160));

+		

+		BLENDFUNCTION bf; 

+		

+		bf.BlendOp = AC_SRC_OVER; 

+		

+		bf.BlendFlags = 0; 

+		

+		bf.SourceConstantAlpha = 0x4f; 

+		

+		bf.AlphaFormat = 0;

+		

+

+		

+		BOOL ret=AlphaBlend(pDC->GetSafeHdc(),rc.left,rc.top,rc.Width(),rc.Height(),memdc.GetSafeHdc(),0,0,rc.Width(),rc.Height(),bf);

+		

+		memdc.SelectObject(pOldBitmap);

+		memdc.DeleteDC();

+		bmp.DeleteObject();

+		

+	}

+	m_SelectArray.RemoveAll();

+

+

+

+

+}

+

+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 = (int)(nSizeX*m_dbScaleFactor);

+	 nsizeY = (int)(nSizeY*m_dbScaleFactor);

+}

+

+void CReaderVCView::OnDocFirstpage() 

+{

+

+	if(m_nPageIndex == 0) return;

+	this->m_nPageIndex = 0;

+	this->LoadPDFPage(m_pDoc, 0);

+	DeleteAllRect();

+}

+

+void CReaderVCView::OnDocGotopage() 

+{

+	CGotoPageDlg dlg;

+	dlg.DoModal();	

+}

+

+void CReaderVCView::OnDocLastpage() 

+{

+// 	FPDF_DOCUMENT doc = FPDF_LoadDocument("d:\\a1.pdf", "");

+//     FPDF_PAGE page = FPDF_LoadPage(doc, 0);

+// 	FPDF_IMAGEOBJECT imgObject = FPDFPageObj_NewImgeObj(doc);

+// 	 long ret = FPDFImageObj_LoadFromFileEx(&page, 1 ,

+// 								 imgObject, "E:\\temp\\temp\\k.gif",TRUE

+// 								 );

+// 	 FPDFImageObj_SetMatrix(imgObject, 240, 0, 0, 160, 1*50, 0 );

+// 	 FPDFPage_InsertObject(page, imgObject);

+// 	 FPDFPage_GenerateContent(page);

+// 	 FPDF_SaveAsFile(doc, "D:\\out.pdf", 0, NULL, 0, NULL, 0);

+//  	 FPDF_ClosePage(page);

+//  	 FPDF_CloseDocument(doc);

+// 	return;

+

+

+	if(m_nPageIndex == m_nTotalPage -1) return;

+	this->m_nPageIndex = m_nTotalPage -1;

+	LoadPDFPage(m_pDoc, m_nPageIndex);

+	DeleteAllRect();

+}

+

+void CReaderVCView::OnDocNextpage() 

+{

+	m_nPageIndex ++ ;

+	m_nPageIndex %= m_nTotalPage;

+	LoadPDFPage(m_pDoc, m_nPageIndex);

+	DeleteAllRect();

+}

+

+void CReaderVCView::OnDocPrepage() 

+{

+	m_nPageIndex --;

+	if(m_nPageIndex < 0) m_nPageIndex = m_nTotalPage-1;

+	LoadPDFPage(m_pDoc, m_nPageIndex);

+	DeleteAllRect();

+}

+

+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_pApp = FPDFDOC_InitFormFillEnviroument(pDoc,this);

+	FPDF_LoadXFA(pDoc);

+

+	FORM_DoDocumentJSAction(m_pApp);

+	FORM_DoDocumentOpenAction(m_pApp);

+//	FORM_OnAfterLoadDocument(m_pApp);

+	FPDF_SetFormFieldHighlightColor(m_pApp, 0, RGB(0,255, 0));

+	FPDF_SetFormFieldHighlightAlpha(m_pApp, 128);

+

+	

+	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){MessageBoxA("Invalidate index");}

+	if(index == m_nPageIndex) return;

+	if(!LoadPDFPage(m_pDoc, index)) return;

+	DeleteAllRect();

+}

+

+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::OnEditFind() 

+{

+	if(m_pTextPage == NULL)

+	{

+		AfxMessageBox("Sorry, the fpdftext.dll may has expired. For keeping on using the dll, please contact sales@foxitsoftware.com.");

+		return;

+	}

+	CFindDlg dlg;

+	dlg.DoModal();	

+}

+

+void CReaderVCView::FindText(CString strFind, BOOL bCase, BOOL bWholeword, int Direction)

+{

+	CString str;

+	str = m_FindInfo.m_strFind;

+	int nFlag = 0;

+	if(bCase) { nFlag |= FPDF_MATCHCASE; }

+	if(bWholeword) { nFlag |= FPDF_MATCHWHOLEWORD; }

+

+	if(NULL == m_pTextPage) return;

+

+	if (strFind.Compare(str) != 0 || nFlag != m_FindInfo.m_nFlag)//new search

+	{

+		if (NULL == m_pTextPage) return;

+		if (NULL != m_pSCHHandle)

+		{

+			FPDFText_FindClose(m_pSCHHandle);

+			m_pSCHHandle  = NULL;

+		}

+

+		int len = MultiByteToWideChar(CP_ACP, 0, strFind.GetBuffer(0), -1, NULL, NULL);

+		wchar_t *pBuf = new wchar_t[len];

+		memset(pBuf, 0, len*sizeof(wchar_t));

+		MultiByteToWideChar(CP_ACP, 0, strFind.GetBuffer(0), strFind.GetLength(), pBuf, len);

+		pBuf[len-1] = L'\0';

+		m_pSCHHandle = FPDFText_FindStart(m_pTextPage, (FPDF_WIDESTRING)pBuf, nFlag, 0);

+		if(NULL == m_pSCHHandle) return;

+		

+        if (m_FindInfo.m_pCurFindBuf != NULL)

+		{

+			delete []m_FindInfo.m_pCurFindBuf;

+			m_FindInfo.m_pCurFindBuf = NULL;

+		}

+		m_FindInfo.m_pCurFindBuf = new wchar_t[len];

+		memset(m_FindInfo.m_pCurFindBuf, 0, len*sizeof(wchar_t));

+		memcpy(m_FindInfo.m_pCurFindBuf, pBuf, len*sizeof(wchar_t));

+

+		delete []pBuf;

+		

+

+		//save the find info

+		m_FindInfo.m_strFind = strFind;

+		m_FindInfo.m_nFlag = nFlag;

+		m_FindInfo.m_nDirection = Direction;

+		m_FindInfo.m_nStartPageIndex = m_nPageIndex;

+		m_FindInfo.m_bFirst = TRUE;

+		

+		

+	}

+	FindNext(Direction);

+}

+

+void CReaderVCView::FindNext(int nDirection)

+{

+	if(NULL == m_pSCHHandle) return;

+	BOOL bResult = FALSE;

+	

+	if (nDirection != m_FindInfo.m_nDirection)

+	{

+		m_FindInfo.m_nDirection = nDirection;

+		m_FindInfo.m_bFirst = TRUE;

+	}

+

+	if (0 == nDirection)// find down

+	{

+		bResult = FPDFText_FindNext(m_pSCHHandle);

+	}

+	if (1 == nDirection)

+	{

+		bResult = FPDFText_FindPrev(m_pSCHHandle);

+	}

+	

+	while(!bResult){

+

+			if (m_rtFind != NULL)

+			{

+				delete [] m_rtFind;

+				m_rtFind = NULL;

+			}

+

+			if (0 == nDirection)

+			{

+				m_nPageIndex ++;

+				m_nPageIndex %= m_nTotalPage;

+				if(!LoadPDFPage(m_pDoc, m_nPageIndex)) return;

+				if (NULL == m_pTextPage) return;

+				if (NULL != m_pSCHHandle)

+				{

+					FPDFText_FindClose(m_pSCHHandle);

+					m_pSCHHandle  = NULL;

+				}

+				m_pSCHHandle = FPDFText_FindStart(m_pTextPage, (FPDF_WIDESTRING)m_FindInfo.m_pCurFindBuf, m_FindInfo.m_nFlag, 0);

+				if(NULL == m_pSCHHandle) break;

+				bResult = FPDFText_FindNext(m_pSCHHandle);

+				if(!bResult && m_nPageIndex == m_FindInfo.m_nStartPageIndex) break;

+			} 

+			else

+			{

+				m_nPageIndex --;

+				if (m_nPageIndex < 0) {m_nPageIndex = m_nTotalPage - 1;}

+				if(!LoadPDFPage(m_pDoc, m_nPageIndex)) return;

+				if (NULL == m_pTextPage) return;

+				if (NULL != m_pSCHHandle)

+				{

+					FPDFText_FindClose(m_pSCHHandle);

+					m_pSCHHandle  = NULL;

+				}

+				m_pSCHHandle = FPDFText_FindStart(m_pTextPage, (FPDF_WIDESTRING)m_FindInfo.m_pCurFindBuf, m_FindInfo.m_nFlag, 0);

+				if(NULL == m_pSCHHandle) break;

+				bResult = FPDFText_FindPrev(m_pSCHHandle);

+				if(!bResult && m_nPageIndex == m_FindInfo.m_nStartPageIndex) break;

+			}

+	}//end while

+	

+	if(!bResult)//find over

+	{

+		FPDFText_FindClose(m_pSCHHandle);

+		m_pSCHHandle = NULL;

+

+		if (m_rtFind != NULL)

+		{

+			delete [] m_rtFind;

+			m_rtFind = NULL;

+		}

+		

+		m_FindInfo.m_bFirst = TRUE;

+		m_FindInfo.m_nDirection = -1;

+		m_FindInfo.m_nFlag = -1;

+		m_FindInfo.m_nStartCharIndex = -1;

+		m_FindInfo.m_nStartPageIndex = -1;

+		m_FindInfo.m_pCurFindBuf = NULL;

+		m_FindInfo.m_strFind = _T("");

+

+		MessageBox("Find complete!", "Find Infomation", MB_OK | MB_ICONINFORMATION);

+		return;

+	}

+	

+	

+	

+	int index = FPDFText_GetSchResultIndex(m_pSCHHandle);

+	if (m_nPageIndex == m_FindInfo.m_nStartPageIndex && index == m_FindInfo.m_nStartCharIndex && !m_FindInfo.m_bFirst )

+	{

+		if (NULL != m_pSCHHandle)

+		{

+			FPDFText_FindClose(m_pSCHHandle);

+			m_pSCHHandle  = NULL;

+		}

+		MessageBox("Find complete!", "Find Infomation", MB_OK | MB_ICONINFORMATION);

+		return;

+	}else{

+		CDC *pDC = GetDC();

+		DrawAllRect(pDC);//update

+

+		int nCount = FPDFText_GetSchCount(m_pSCHHandle);

+		int nRects = FPDFText_CountRects(m_pTextPage, index, nCount);

+		if (m_rtFind != NULL)

+		{

+			delete [] m_rtFind;

+			m_rtFind = NULL;

+		}

+		m_rtFind = new PDFRect[nRects];

+		m_nRectNum = nRects;

+		for (int i=0; i<nRects; i++)

+		{	

+			double left, top, right, bottom;	

+			FPDFText_GetRect(m_pTextPage, i, &left, &top, &right, &bottom);

+			m_rtFind[i].m_dbLeft = left;

+			m_rtFind[i].m_dbTop = top;

+			m_rtFind[i].m_dbRight = right;

+			m_rtFind[i].m_dbBottom = bottom;

+		}

+		DrawAllRect(pDC);//draw new rect

+		ReleaseDC(pDC);

+	}

+

+	if (m_FindInfo.m_bFirst)

+	{//find first string, store info;

+		m_FindInfo.m_bFirst = FALSE;

+		m_FindInfo.m_nStartCharIndex = index;

+		m_FindInfo.m_nStartPageIndex = m_nPageIndex; 

+	}

+	

+}

+

+void CReaderVCView::DrawReverse(CDC *pDC, CRect rect)

+{

+	CRect rt = rect;

+	rect.left = __min(rt.left, rt.right);

+	rect.right = __max(rt.left, rt.right);

+	rect.top = __min(rt.top, rt.bottom);

+	rect.bottom = __max(rt.top, rt.bottom);

+

+	ASSERT(pDC);

+	int bmp_width=abs(rect.Width());

+	int bmp_height=abs(rect.Height());	

+	HBITMAP hbmp = CreateCompatibleBitmap(pDC->m_hDC, bmp_width, bmp_height);

+	CDC MemDC;

+	MemDC.CreateCompatibleDC(pDC);

+	HBITMAP holdbmp  = (HBITMAP)MemDC.SelectObject(hbmp);

+	// copy screen DC to memory DC

+	BitBlt(MemDC, 0, 0, bmp_width, bmp_height,	pDC->m_hDC, rect.left,rect.top, SRCCOPY);

+	MemDC.SelectObject(holdbmp);

+	

+	BITMAPINFO bmi;

+	memset(&bmi, 0, sizeof bmi);

+	bmi.bmiHeader.biSize = sizeof bmi.bmiHeader;

+	bmi.bmiHeader.biBitCount = 24;

+	bmi.bmiHeader.biClrImportant = 0;

+	bmi.bmiHeader.biClrUsed = 0;

+	bmi.bmiHeader.biCompression = BI_RGB;

+	bmi.bmiHeader.biHeight = bmp_height;

+	bmi.bmiHeader.biPlanes = 1;

+	bmi.bmiHeader.biSizeImage = 0;

+	bmi.bmiHeader.biWidth = bmp_width;

+	bmi.bmiHeader.biXPelsPerMeter = 0;

+	bmi.bmiHeader.biYPelsPerMeter = 0;

+	

+	// get bitmap stream

+	int ret = GetDIBits(MemDC, hbmp, 0,bmp_height, NULL, &bmi, DIB_RGB_COLORS);

+	

+	int size = bmi.bmiHeader.biSizeImage;

+	

+	BYTE* pBits = new BYTE[size];

+	memset(pBits, 0, size);

+	ret = GetDIBits(MemDC, hbmp, 0,bmp_height, pBits, &bmi, DIB_RGB_COLORS);

+	ret = GetLastError();

+	DeleteObject(hbmp);

+	MemDC.DeleteDC();

+	for (int row = 0; row < bmp_height; row ++) {

+		int pitch = (bmp_width * 3 + 3) / 4 * 4;

+		int rowpos = row * pitch;

+		for(int col = 0; col < bmp_width; col ++){

+			int i = rowpos + col * 3;	

+			pBits[i]		= 255-pBits[i] ;		

+			pBits[i + 1]	= 255-pBits[i + 1];

+			pBits[i + 2]	= 255-pBits[i + 2];	

+		}

+	}

+	ret = SetDIBitsToDevice(pDC->m_hDC,rect.left,rect.top,bmp_width, bmp_height,0, 0, 0, bmp_height, pBits, &bmi, DIB_RGB_COLORS);

+	delete []pBits;	

+

+}

+

+void CReaderVCView::DrawAllRect(CDC *pDC)

+{

+	int i;

+	int left, top, right, bottom;

+

+	int nSizeX = 0; 

+	int nSizeY = 0;

+//	int temp = 0;	

+	if (1 == m_nRotateFlag || 3 == m_nRotateFlag)

+	{

+		nSizeX = m_nActualSizeY;

+		nSizeY = m_nActualSizeX;

+	}

+	else

+	{

+		nSizeX = m_nActualSizeX;

+		nSizeY = m_nActualSizeY;

+	}

+	ASSERT(pDC);

+	if (m_rtFind != NULL)

+	{

+		for (i=0; i<m_nRectNum; i++)

+		{

+			

+			PDFRect rect = m_rtFind[i];

+			FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nSizeX * m_dbScaleFactor),

+				(int)(nSizeY * m_dbScaleFactor), m_nRotateFlag, rect.m_dbLeft, rect.m_dbTop, &left, &top);

+			FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nSizeX * m_dbScaleFactor),

+				(int)(nSizeY * m_dbScaleFactor), m_nRotateFlag, rect.m_dbRight, rect.m_dbBottom, &right, &bottom);

+			CRect rt(left, top, right, bottom);

+			DrawReverse(pDC, rt);

+

+		}

+	}

+

+	if (m_rtArray.GetSize() != 0)

+	{

+		for (i=0; i<m_rtArray.GetSize(); i++)

+		{

+			PDFRect rect = m_rtArray.GetAt(i);

+			FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nSizeX * m_dbScaleFactor),

+				(int)(nSizeY * m_dbScaleFactor), m_nRotateFlag, rect.m_dbLeft, rect.m_dbTop, &left, &top);

+			FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nSizeX * m_dbScaleFactor),

+				(int)(nSizeY * m_dbScaleFactor), m_nRotateFlag, rect.m_dbRight, rect.m_dbBottom, &right, &bottom);

+			CRect rt(left, top, right, bottom);

+			DrawReverse(pDC, rt);

+		}

+	}

+}

+

+void CReaderVCView::DeleteAllRect()

+{

+	CDC *pDC = GetDC();

+	DrawAllRect(pDC);

+	ReleaseDC(pDC);

+

+	if (m_rtFind != NULL)

+	{

+		delete []m_rtFind;

+		m_rtFind = NULL;

+	}

+	

+	if (m_rtArray.GetSize() != 0)

+	{

+		m_rtArray.RemoveAll();

+	}

+}

+

+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 = (int)(npagewidth / 72 *logpixelsx + 0.5f);

+			int nsizeY = (int)(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

+

+	double page_x = 0;

+	double page_y = 0;

+	DeviceToPage(point, page_x, page_y);

+

+	if(m_pApp)

+	{

+		FPDF_BOOL b=  FORM_OnLButtonDown(m_pApp, m_pPage,ComposeFlag(),page_x, page_y);

+		if(b)

+			return;

+	}

+	DeleteAllRect();

+	LoadMyCursor(1);

+	m_ptLBDown = point;

+

+

+	if (m_bSelect)

+	{

+		m_bHasChar = GetCharIndexByPoint(point, m_nStartIndex);

+		CreateCaret(point);

+	}

+	if (m_bHand)

+	{	

+		m_nPosH = GetScrollPos(SB_HORZ);//SetScrollPos(SB_VERT, point.y, TRUE);

+		m_nPosV = GetScrollPos(SB_VERT);

+	}

+	CView::OnLButtonDown(nFlags, point);

+}

+

+void CReaderVCView::OnLButtonUp(UINT nFlags, CPoint point) 

+{

+

+	// TODO: Add your message handler code here and/or call default

+	double page_x = 0;

+	double page_y = 0;

+	DeviceToPage(point, page_x, page_y);

+

+	if(m_pApp)

+	{

+		if(FORM_OnLButtonUp(m_pApp, m_pPage,ComposeFlag(), page_x, page_y))

+			return;

+	}

+	LoadMyCursor();

+	m_ptLBUp = point;

+	if (m_bSelect || m_bSnap)

+	{

+		CDC *pDC  = GetDC();

+		CPen *pOldPen;

+		CPen pen;

+		CBrush *pOldBr;

+		CRect rect;

+		pen.CreatePen(PS_DASH, 2, RGB(255,0,0));

+		pOldPen = pDC->SelectObject(&pen);

+		pOldBr = (CBrush*) (pDC->SelectStockObject(NULL_BRUSH));

+		int nOldRop = pDC->SetROP2(R2_XORPEN);

+		pDC->Rectangle(m_rtOld);

+		pDC->SetROP2(nOldRop);

+		m_rtOld.left = m_rtOld.top = m_rtOld.right = m_rtOld.bottom = 0;

+		ReleaseDC(pDC);

+	}

+	

+	if (m_bSnap)

+	{	

+		BOOL open = OpenClipboard();

+		if (open)

+		{

+			::EmptyClipboard();

+			int bmpWidth = abs(point.x - m_ptLBDown.x);

+			int bmpHeight = abs(point.y - m_ptLBDown.y);

+			if (bmpHeight == 0 || bmpWidth == 0)return;

+			CRect bmpRect(m_ptLBDown, point);

+			CClientDC dc(this);

+			CBitmap *pBitmap = new CBitmap();

+			pBitmap->CreateCompatibleBitmap(&dc,bmpWidth,bmpHeight);

+			CDC memDC;

+			memDC.CreateCompatibleDC(&dc);

+			memDC.SelectObject(pBitmap);

+			CBrush whiteBrush(RGB(255,255,255));

+			//memDC.FillRect(bmpRect,&whiteBrush);

+			memDC.BitBlt(0, 0, bmpRect.Width(), bmpRect.Height(),&dc, bmpRect.left, bmpRect.top,SRCCOPY);

+			HBITMAP hBitmap = (HBITMAP) *pBitmap;

+			:: SetClipboardData(CF_BITMAP, hBitmap);

+			::CloseClipboard();

+			MessageBox("The selected area has been copied to clipboard!");

+			delete pBitmap;

+		}

+	}

+	

+	FPDF_LINK hlink=NULL;

+	double pdfx,pdfy;

+

+	int nActualRangeX = 0;

+	int nActualRangeY = 0;

+	if ( m_nRotateFlag % 2 == 0 )

+	{

+		nActualRangeX = m_nActualSizeX;

+		nActualRangeY = m_nActualSizeY;

+	}else{

+		nActualRangeX = m_nActualSizeY;

+		nActualRangeY = m_nActualSizeX;

+	}

+

+	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+		(int)(nActualRangeY * m_dbScaleFactor),m_nRotateFlag,point.x,point.y,&pdfx,&pdfy);

+	hlink=FPDFLink_GetLinkAtPoint(m_pPage,pdfx,pdfy);

+	if (hlink)

+	{

+		FPDF_ACTION haction=NULL;

+		FPDF_DEST hLinkDest=NULL;

+		haction=FPDFLink_GetAction(hlink);

+		hLinkDest=FPDFLink_GetDest(m_pDoc,hlink);

+		if (haction)

+		{

+			int nActionType=FPDFAction_GetType(haction);

+			switch(nActionType)

+			{

+			case PDFACTION_UNSUPPORTED: // Unsupported action type

+				break;

+			case PDFACTION_GOTO:		// Go to a destination within current document	

+				{

+					FPDF_LINK hActLinkDest =  FPDFAction_GetDest(m_pDoc,haction);

+					if (hActLinkDest)

+					{

+						int nPageIndex=FPDFDest_GetPageIndex(m_pDoc,hActLinkDest);

+						GotoPage(nPageIndex);

+					}

+				}

+				break;

+			case PDFACTION_REMOTEGOTO:	// Go to a destination within another document

+				

+				//	FPDFAction_GetFilePath(...);

+				//	.....	

+				break;

+			case PDFACTION_URI:		// Universal Resource Identifier, including web pages and 

+				// other Internet based resources

+				//	int nsize= FPDFAction_GetURIPath(m_pDoc,haction);

+				//	...

+				break;

+			case PDFACTION_LAUNCH:			// Launch an application or open a file

+				//	FPDFAction_GetFilePath(...)

+				break;

+			default :

+				break;

+			}

+		}

+		else if (hLinkDest)

+		{

+			int nPageIndex=FPDFDest_GetPageIndex(m_pDoc,hLinkDest);

+			GotoPage(nPageIndex);

+		}

+	}

+	CView::OnLButtonUp(nFlags, point);

+}

+

+void CReaderVCView::OnMouseMove(UINT nFlags, CPoint point) 

+{

+	// TODO: Add your message handler code here and/or call default

+	double page_x = 0;

+	double page_y = 0;

+	DeviceToPage(point, page_x, page_y);

+

+	if(m_pApp)

+	{

+		if(FORM_OnMouseMove(m_pApp, m_pPage,ComposeFlag(), page_x, page_y))

+			return;

+	}

+	if (nFlags == MK_LBUTTON)

+	{

+		LoadMyCursor(1);

+	}else{LoadMyCursor();}

+	

+	CDC *pDC = GetDC();

+

+	if (m_bSelect && nFlags == MK_LBUTTON)

+	{

+		if (m_bHasChar)

+		{

+			if (m_ptOld.x == 0 && m_ptOld.y == 0){m_ptOld = m_ptLBDown;}

+	

+			int nIndex = 0;

+			if (!GetCharIndexByPoint(point, nIndex)) return;

+			if(nIndex == m_nEndIndex) return;

+			

+			DrawAllRect(pDC);//update all rect

+			

+			m_nEndIndex = nIndex;

+			GetRects(m_nStartIndex, m_nEndIndex);	//get the rect and store into m_rtArray

+			DrawAllRect(pDC);//draw new rect	

+		}

+		else 

+		{

+			CPen *pOldPen;

+			CPen pen;

+			CBrush *pOldBr;

+			CRect rect;

+			pen.CreatePen(PS_DASH, 2, RGB(255,0,0));

+			pOldPen = pDC->SelectObject(&pen);

+			pOldBr = (CBrush*) (pDC->SelectStockObject(NULL_BRUSH));

+			int nOldRop = pDC->SetROP2(R2_XORPEN);

+			int nModle = pDC->Rectangle(m_rtOld);

+		

+			

+			DrawAllRect(pDC);//update all rect

+			rect = SelectSegment(m_ptLBDown, point);

+			DrawAllRect(pDC);

+

+			pDC->Rectangle(rect);

+			pDC->SelectObject(pOldBr);

+			pDC->SelectObject(pOldPen);

+			pDC->SetROP2(nModle);

+			m_rtOld = rect;	

+		}

+	}

+

+	if (m_bHand && nFlags == MK_LBUTTON)

+	{

+		int curPos, prevPos;

+		//CChildFrame *pFrame = (CChildFrame *) GetParentFrame();

+		

+		int dy = m_ptLBDown.y - point.y;

+		prevPos = m_nPosV;

+		curPos = prevPos + dy;

+		prevPos = SetScrollPos(SB_VERT, curPos, TRUE);

+		curPos = GetScrollPos(SB_VERT);

+		int distance;

+		distance = prevPos - curPos;

+		m_nStartY += distance;

+		ScrollWindow(0, distance);

+	

+		dy = m_ptLBDown.x - point.x;

+		prevPos = m_nPosH;

+		curPos = prevPos + dy;

+		prevPos = SetScrollPos(SB_HORZ, curPos, TRUE);

+		curPos = GetScrollPos(SB_HORZ);

+		distance = prevPos - curPos;

+		m_nStartX += distance;

+		ScrollWindow(distance, 0);

+

+	}

+	if (m_bSnap && nFlags == MK_LBUTTON)

+	{

+		CPen *pOldPen;

+		CPen pen;

+		CBrush *pOldBr;

+		CRect rect(m_ptLBDown, point);

+		pen.CreatePen(PS_DASH, 2, RGB(255,0,0));

+		pOldPen = pDC->SelectObject(&pen);

+		pOldBr = (CBrush*) (pDC->SelectStockObject(NULL_BRUSH));

+		int nOldRop = pDC->SetROP2(R2_XORPEN);

+		int nModle = pDC->Rectangle(m_rtOld);

+		

+		pDC->Rectangle(rect);

+		pDC->SelectObject(pOldBr);

+		pDC->SelectObject(pOldPen);

+		pDC->SetROP2(nModle);

+		m_rtOld = rect;

+		

+	}

+	

+	FPDF_LINK hlink=NULL;

+	double pdfx,pdfy;

+

+	int nActualRangeX = 0;

+	int nActualRangeY = 0;

+	if ( m_nRotateFlag % 2 == 0 )

+	{

+		nActualRangeX = m_nActualSizeX;

+		nActualRangeY = m_nActualSizeY;

+	}else{

+		nActualRangeX = m_nActualSizeY;

+		nActualRangeY = m_nActualSizeX;

+	}

+

+	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+		(int)(nActualRangeY * m_dbScaleFactor),m_nRotateFlag,point.x,point.y,&pdfx,&pdfy);

+	hlink=FPDFLink_GetLinkAtPoint(m_pPage,pdfx,pdfy);

+	if (hlink)

+	{

+		HCURSOR hCur = AfxGetApp()->LoadCursor(IDC_CURSOR4);

+	    ::SetCursor(hCur);

+	}

+	ReleaseDC(pDC);

+// 		

+ 	CView::OnMouseMove(nFlags, point);

+}

+

+void CReaderVCView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 

+{

+	// TODO: Add your message handler code here and/or call default

+// 	double page_x = 0;

+// 	double page_y = 0;

+// 	DeviceToPage(point, page_x, page_y);

+

+	if(m_pApp)

+	{

+		if(FORM_OnKeyDown(m_pApp, m_pPage, nChar, ComposeFlag()))

+			return;

+	}

+	switch(nChar)

+	{

+	case 35:

+		OnDocLastpage();	

+		break;

+	case 36:

+		OnDocFirstpage();

+		break;

+	case 37:

+		this->OnDocPrepage();

+		break;

+	case 39:

+		this->OnDocNextpage();

+		break;

+	case 38:

+		

+		break;

+	case 40:

+		

+		break;

+	default:

+		break;

+	}

+	CView::OnKeyDown(nChar, nRepCnt, nFlags);

+}

+

+void CReaderVCView::OnToolSnapshot() 

+{

+	m_bSnap = TRUE;

+	m_bHand = FALSE;

+	m_bSelect = FALSE;

+	this->HideCaret();

+}

+

+void CReaderVCView::OnToolSelect() 

+{

+	if(m_pTextPage == NULL)

+	{

+		AfxMessageBox("Sorry, the fpdftext.dll may has expired. For keeping on using the dll, please contact sales@foxitsoftware.com.");

+		return;

+	}

+	m_bSnap = FALSE;

+	m_bHand = FALSE;

+	m_bSelect = TRUE;

+}

+

+void CReaderVCView::OnToolHand() 

+{

+	m_bSnap = FALSE;

+	m_bHand = TRUE;

+	m_bSelect = FALSE;

+	this->HideCaret();

+}

+

+void CReaderVCView::LoadMyCursor(int nflag)

+{

+	HCURSOR hCur;

+	if (nflag == 1)

+	{

+		if (m_bSelect)

+		{

+			hCur = AfxGetApp()->LoadCursor(IDC_CURSOR3);

+		}

+		else if (m_bSnap)

+		{

+			hCur = AfxGetApp()->LoadStandardCursor(IDC_CROSS);

+		}

+		else

+		{

+			hCur = AfxGetApp()->LoadCursor(IDC_CURSOR1);

+		}

+	}

+	else if (m_bHand)

+	{

+		hCur = AfxGetApp()->LoadCursor(IDC_CURSOR2);

+	}

+	else if (m_bSelect)

+	{

+		hCur = AfxGetApp()->LoadCursor(IDC_CURSOR3);

+	}

+	else if (m_bSnap)

+	{

+		hCur = AfxGetApp()->LoadStandardCursor(IDC_CROSS);

+	}else 

+	{

+		hCur = AfxGetApp()->LoadStandardCursor(IDC_ARROW);

+	}

+	::SetCursor(hCur);

+}

+

+BOOL CReaderVCView::DeviceToPage(CPoint pt, double& page_x, double& page_y)

+{

+//	if(NULL == m_pTextPage) return FALSE;

+	int nActualRangeX = 0;

+	int nActualRangeY = 0;

+	if ( m_nRotateFlag % 2 == 0 )

+	{

+		nActualRangeX = m_nActualSizeX;

+		nActualRangeY = m_nActualSizeY;

+	}else{

+		nActualRangeX = m_nActualSizeY;

+		nActualRangeY = m_nActualSizeX;

+	}

+// 	switch ( m_nRotateFlag % 4 )

+// 	{

+// 	case 0:

+// 	case 2:

+// 		{

+// 			FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, m_nActualSizeX * m_dbScaleFactor,

+// 			m_nActualSizeY * m_dbScaleFactor, m_nRotateFlag, pt.x, pt.y, &page_x, &page_y);

+// 			break;

+// 		}

+// 	case 1:

+// 	case 3:

+// 		{

+// 			FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, m_nActualSizeY * m_dbScaleFactor,

+// 				m_nActualSizeX * m_dbScaleFactor, m_nRotateFlag, pt.x, pt.y, &page_x, &page_y);

+// 			break;

+// 		}

+// 	}

+

+ 	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+ 		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, pt.x, pt.y, &page_x, &page_y);

+	return TRUE;

+}

+

+BOOL CReaderVCView::PageToDevice(double page_x, double page_y, CPoint& pt)

+{

+	int nActualRangeX = 0;

+	int nActualRangeY = 0;

+	if ( m_nRotateFlag % 2 == 0 )

+	{

+		nActualRangeX = m_nActualSizeX;

+		nActualRangeY = m_nActualSizeY;

+	}else{

+		nActualRangeX = m_nActualSizeY;

+		nActualRangeY = m_nActualSizeX;

+	}

+

+	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, page_x, page_y, (int*)&pt.x, (int*)&pt.y);

+	return TRUE;

+}

+

+BOOL CReaderVCView::GetCharIndexByPoint(CPoint pt, int &nIndex)

+{

+	double page_x = 0.0f;

+	double page_y = 0.0f;

+

+	if(NULL == m_pTextPage) return FALSE;

+	int nActualRangeX = 0;

+	int nActualRangeY = 0;

+	if ( m_nRotateFlag % 2 == 0 )

+	{

+		nActualRangeX = m_nActualSizeX;

+		nActualRangeY = m_nActualSizeY;

+	}else{

+		nActualRangeX = m_nActualSizeY;

+		nActualRangeY = m_nActualSizeX;

+	}

+	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+ 		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, pt.x, pt.y, &page_x, &page_y);

+// 	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, m_nActualSizeX * m_dbScaleFactor,

+// 		m_nActualSizeY * m_dbScaleFactor, m_nRotateFlag, pt.x, pt.y, &page_x, &page_y);

+	

+	nIndex = FPDFText_GetCharIndexAtPos(m_pTextPage, page_x, page_y, 10, 10);

+	if (-3 == nIndex || -1 == nIndex) return FALSE;

+	return TRUE;

+}

+

+void CReaderVCView::CreateCaret(CPoint pt)

+{

+	double a, b, c, d;

+	int nIndex = 0;

+	int nAcent = 0, nDecent = 0;

+	double orgx = 0.0f, orgy = 0.0f;

+	double fontsize = 0.0f;

+	int left = 0, right = 0;

+	int top = 0, bottom = 0;

+	//double left_char, right_char, top_char, bottom_char;//char bounding box	

+	FPDF_FONT pfont = NULL;

+

+	if(!GetCharIndexByPoint(pt, nIndex)) return;

+	fontsize = FPDFText_GetFontSize(m_pTextPage, nIndex);

+// 	FPDFText_GetOrigin(m_pTextPage, nIndex, &orgx, &orgy);

+// 	pfont = FPDFText_GetFont(m_pTextPage, nIndex);

+// 	if(NULL == pfont) return;

+// 	nAcent = FPDFFont_GetAscent(pfont);

+// 	nDecent = FPDFFont_GetDescent(pfont);

+// 	FPDFText_GetMatrix(m_pTextPage, nIndex, &a, &b, &c, &d);

+// 	nAcent =(int)((nAcent * fontsize / 1000.0f) * d + orgy + 0.5f);

+// 	nDecent = (int)((nDecent * fontsize / 1000.0f) * d + orgy + 0.5f);

+// 

+// 	int nActualRangeX = 0;

+// 	int nActualRangeY = 0;

+// 	if ( m_nRotateFlag % 2 == 0 )

+// 	{

+// 		nActualRangeX = m_nActualSizeX;

+// 		nActualRangeY = m_nActualSizeY;

+// 	}else{

+// 		nActualRangeX = m_nActualSizeY;

+// 		nActualRangeY = m_nActualSizeX;

+// 	}

+// 	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+//  		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, orgx, nAcent, &left, &top);

+// 

+// 	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+//  		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, orgx, nDecent, &right, &bottom);

+// 

+// // 	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, m_nActualSizeX * m_dbScaleFactor,

+// // 		m_nActualSizeY * m_dbScaleFactor, m_nRotateFlag, orgx, nAcent, &left, &top);

+// // 

+// // 	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, m_nActualSizeX * m_dbScaleFactor,

+// // 		m_nActualSizeY * m_dbScaleFactor, m_nRotateFlag, orgx, nDecent, &right, &bottom);

+// 

+// 	this->CreateSolidCaret(2, abs(top - bottom));

+// 	

+// /*	FPDFText_GetCharBox(m_pTextPage, nIndex, &left_char, &right_char, &bottom_char, &top_char);

+// 

+// 	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, m_nActualSizeX * m_dbScaleFactor,

+// 		m_nActualSizeY * m_dbScaleFactor, m_nRotateFlag, left_char, top_char, &left, &top);

+// 	FPDF_PageToDevice(m_pPage, m_nStartX, m_nStartY, m_nActualSizeX * m_dbScaleFactor,

+// 		m_nActualSizeY * m_dbScaleFactor, m_nRotateFlag, right_char, bottom_char, &right, &bottom);*/

+// 	this->SetCaretPos(CPoint(left, top-2));

+// 	this->ShowCaret();

+	

+

+}

+

+void CReaderVCView::GetRects(int nStart, int nEnd)

+{

+	int temp, nCount;

+	nCount = nEnd - nStart;

+	if (nCount < 0)

+	{

+		temp = nEnd;

+		nEnd = nStart;

+		nStart = temp;

+

+		nCount = abs(nCount);

+	}

+	 nCount ++;

+

+	 int num = FPDFText_CountRects(m_pTextPage, nStart, nCount);

+	 if(num == 0) return;

+	 

+	 if (m_rtArray.GetSize() > 0)

+	 {

+		 m_rtArray.RemoveAll();

+	 }

+	 PDFRect rect;

+	 for (int i=0; i<num; i++)

+	 {

+		 FPDFText_GetRect(m_pTextPage, i, &rect.m_dbLeft, &rect.m_dbTop, &rect.m_dbRight, &rect.m_dbBottom);

+		 m_rtArray.Add(rect);

+	 }

+	return;

+}

+

+CRect CReaderVCView::SelectSegment(CPoint pt_lt, CPoint pt_rb)

+{

+	CRect rect(pt_lt, pt_rb);

+// 	double left, top, right, bottom;

+// 	int start_index = 0, nCount = 0;

+// 	int nRect = 0;

+// 

+// 	int nActualRangeX = 0;

+// 	int nActualRangeY = 0;

+// 	if ( m_nRotateFlag % 2 == 0 )

+// 	{

+// 		nActualRangeX = m_nActualSizeX;

+// 		nActualRangeY = m_nActualSizeY;

+// 	}else{

+// 		nActualRangeX = m_nActualSizeY;

+// 		nActualRangeY = m_nActualSizeX;

+// 	}

+// 	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+// 		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, rect.left, rect.top, &left, &top);

+// 	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, (int)(nActualRangeX * m_dbScaleFactor),

+// 		(int)(nActualRangeY * m_dbScaleFactor), m_nRotateFlag, rect.right, rect.bottom, &right, &bottom);

+// 

+// // 	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, m_nActualSizeX * m_dbScaleFactor,

+// // 		m_nActualSizeY * m_dbScaleFactor, m_nRotateFlag, rect.left, rect.top, &left, &top);

+// // 	FPDF_DeviceToPage(m_pPage, m_nStartX, m_nStartY, m_nActualSizeX * m_dbScaleFactor,

+// // 		m_nActualSizeY * m_dbScaleFactor, m_nRotateFlag, rect.right, rect.bottom, &right, &bottom);

+// 

+// 	int num = FPDFText_CountBoundedSegments(m_pTextPage, left, top, right, bottom);

+// 

+// 	if (m_rtArray.GetSize() > 0)

+// 	{

+// 		m_rtArray.RemoveAll();

+// 	}

+// 

+// 	CDC *pDC = GetDC();

+// 	for (int i=0; i<num; i++)

+// 	{

+// 		FPDFText_GetBoundedSegment(m_pTextPage, i, &start_index, &nCount);

+// 		nRect = FPDFText_CountRects(m_pTextPage, start_index, nCount);

+// 

+// 		PDFRect rect_select;

+// 		for (int j=0; j<num; j++)

+// 		{

+// 			FPDFText_GetRect(m_pTextPage, j, &rect_select.m_dbLeft, &rect_select.m_dbTop, &rect_select.m_dbRight, &rect_select.m_dbBottom);

+// 			m_rtArray.Add(rect_select);

+// 		}

+// 	}

+// 	ReleaseDC(pDC);

+	return rect;

+}

+

+void CReaderVCView::OnToolPdf2txt() 

+{

+	// TODO: Add your command handler code here

+	if(m_pTextPage == NULL)

+	{

+		AfxMessageBox("Sorry, the fpdftext.dll may has expired. For keeping on using the dll, please contact sales@foxitsoftware.com.");

+		return;

+	}

+	CConvertDlg condlg;

+	if(condlg.DoModal() == IDOK)

+	{

+		int nFlag=condlg.m_nFlag;

+		CReaderVCDoc *pDoc = this->GetDocument();

+		CString pdfname=pDoc->m_strPDFName;

+		CString strname=pdfname,stem;

+		if (strname.Find(".pdf") != -1 || strname.Find(".PDF") != -1)

+		{

+			int startatr=strname.ReverseFind('\\');

+			stem=strname.Mid(startatr+1,strname.GetLength()-startatr-5);

+		}

+		CString defaultname=stem+".txt";

+

+		char szFilter[] = "Text File(*.txt)|*.txt";

+		CFileDialog dlg(FALSE, ".txt", defaultname, OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, szFilter, NULL);

+

+		if (dlg.DoModal() == IDOK)

+		{

+// 			CString txtname=dlg.GetPathName();

+// 			BOOL bFlag=FPDFText_PDFToText(pdfname,txtname,nFlag,NULL);

+// 			if(! bFlag) 

+// 				MessageBox("Convert Failure!");

+		}

+	}	

+}

+

+void CReaderVCView::SyncScroll()

+{

+	CRect rect;                                                               

+	GetClientRect(rect);                                                      

+	

+	int nSizeX = 0; 

+	int nSizeY = 0;

+	//int temp = 0;

+

+	if (1 == m_nRotateFlag || 3 == m_nRotateFlag)

+	{

+		nSizeX = m_nActualSizeY;

+		nSizeY = m_nActualSizeX;

+	}

+	else

+	{

+		nSizeX = m_nActualSizeX;

+		nSizeY = m_nActualSizeY;

+	}

+	

+	SCROLLINFO scrinfo;                                                       

+	scrinfo.cbSize = sizeof(SCROLLINFO);                                      

+	GetScrollInfo(SB_HORZ, &scrinfo);                                         

+	scrinfo.nMin =0;                                                          

+	scrinfo.nMax = (int)(nSizeX * m_dbScaleFactor);                                                 

+	scrinfo.nPage = (unsigned int)(__min(nSizeX * m_dbScaleFactor, rect.Width()));                              

+	if (nSizeX * m_dbScaleFactor < rect.Width()){scrinfo.fMask |= SIF_DISABLENOSCROLL;}         

+	SetScrollInfo(SB_HORZ, &scrinfo);                                         

+	SetScrollPos(SB_HORZ, 0);                                           

+	//m_nPosH = nPosH;                                                          

+	

+	GetScrollInfo(SB_VERT, &scrinfo);                                         

+	scrinfo.nMin = 0;                                                         

+	scrinfo.nMax = (int)(nSizeY * m_dbScaleFactor);                                             

+	scrinfo.nPage =(unsigned int)( __min(nSizeY * m_dbScaleFactor, rect.Height()));                             

+	if (nSizeY * m_dbScaleFactor < rect.Height()){scrinfo.fMask |= SIF_DISABLENOSCROLL;}        

+	SetScrollInfo(SB_VERT, &scrinfo);                                         

+	SetScrollPos(SB_VERT, 0);                                             

+	                                                     

+}

+

+void CReaderVCView::OnSize(UINT nType, int cx, int cy) 

+{

+	CView::OnSize(nType, cx, cy);

+	SyncScroll();

+	if(m_bmp)

+	{

+		FPDFBitmap_Destroy(m_bmp);

+		m_bmp = NULL;

+	}

+

+	m_bmp = FPDFBitmap_Create(cx, cy, 0);

+

+	// TODO: Add your message handler code here	

+}

+

+void CReaderVCView::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 

+{

+	// TODO: Add your message handler code here and/or call default

+	int prevPos = GetScrollPos(SB_HORZ);                               

+	int curPos = prevPos;                                              

+	int nMin, nMax, nPage;                                             

+	GetScrollRange(SB_HORZ, &nMin, &nMax);                             

+	SCROLLINFO si;                                                     

+	GetScrollInfo(SB_HORZ, &si);                                       

+	nPage = si.nPage;                                                  

+	

+	switch(nSBCode)                                                    

+	{                                                                  

+	case SB_TOP:                                                       

+		curPos = nMin;                                                   

+		break;                                                           

+	case SB_BOTTOM:                                                    

+		curPos = nMax;                                                   

+		break;                                                           

+	case SB_LINEUP:                                                    

+		curPos --;                                                       

+		break;                                                         

+	case SB_LINEDOWN:                                                  

+		curPos ++;                                                       

+		break;                                                         

+	case SB_ENDSCROLL:                                                 

+		return;                                                          

+	case SB_PAGEDOWN:                                                  

+		curPos += nPage;                                                 

+		break;                                                           

+	case SB_PAGEUP:                                                    

+		curPos -= nPage;                                                 

+		break;                                                         

+	case SB_THUMBPOSITION:                                             

+		curPos = si.nTrackPos;                                           

+		break;                                                         

+	case SB_THUMBTRACK:                                                

+		curPos = si.nTrackPos;                                           

+		break;                                                         

+	}                                                                  

+	

+	if (curPos < nMin) { curPos = nMin;}                               

+	if(curPos > nMax){ curPos = nMax;}                                 

+	SetScrollPos(SB_HORZ, curPos);                                     

+

+	int distance;                                                      

+	distance = prevPos - curPos;                                                                     

+	m_nStartX += distance;                                                                                

+	ScrollWindow(distance, 0);                                  

+	CRect rect;

+	GetClientRect(rect);

+	CRect rtnew(rect.left, rect.top, rect.left+distance, rect.bottom);

+	InvalidateRect(&rtnew);

+	

+	CView::OnHScroll(nSBCode, nPos, pScrollBar);

+}

+

+void CReaderVCView::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 

+{

+	// TODO: Add your message handler code here and/or call default                                   

+	int prevPos = GetScrollPos(SB_VERT);                                        

+	int curPos = prevPos;                                                       

+	int nMin, nMax, nPage;                                                      

+	GetScrollRange(SB_VERT, &nMin, &nMax);                                      

+	SCROLLINFO si;                                                              

+	GetScrollInfo(SB_VERT, &si);                                                

+	nPage = si.nPage;                                                           

+                                                                            

+	switch(nSBCode)                                                             

+	{                                                                           

+	case SB_TOP:                                                                

+		curPos = nMin;                                                            

+		break;                                                                    

+	case SB_BOTTOM:                                                             

+		curPos = nMax;                                                            

+		break;                                                                    

+	case SB_LINEUP:                                                             

+		curPos --;                                                                

+		break;                                                                  

+	case SB_LINEDOWN:                                                           

+		curPos ++;                                                                

+		break;                                                                  

+	case SB_ENDSCROLL:                                                          

+		return;                                                                   

+	case SB_PAGEDOWN:                                                           

+		curPos += nPage;                                                          

+		break;                                                                    

+	case SB_PAGEUP:                                                             

+		curPos -= nPage;                                                          

+		break;                                                                  

+	case SB_THUMBPOSITION:                                                      

+		curPos = si.nTrackPos;                                                    

+		break;                                                                  

+	case SB_THUMBTRACK:                                                         

+		curPos = si.nTrackPos;                                                    

+		break;                                                                  

+	}                                                                           

+                                                                            

+	if (curPos < nMin) { curPos = nMin;}                                        

+	if(curPos > nMax){ curPos = nMax;}                                          

+	SetScrollPos(SB_VERT, curPos);                                                                                                      

+                                                                            

+	int distance;                                                                                                        

+	distance = prevPos - curPos;                                                

+	m_nStartY += distance;                                                                                                  

+	ScrollWindow(0, distance);                                           

+

+	CRect rect;

+	GetClientRect(rect);

+	CRect rtnew(rect.left, rect.bottom + distance, rect.right, rect.bottom);

+	CRect rtnew2(rect.left, rect.top, rect.right, rect.top + distance);

+	InvalidateRect(&rtnew);

+	InvalidateRect(&rtnew2);

+

+	CView::OnVScroll(nSBCode, nPos, pScrollBar);

+}

+

+void CReaderVCView::OnToolExtractlinks() 

+{

+	if(m_pTextPage == NULL)

+	{

+		AfxMessageBox("Sorry, the fpdftext.dll may has expired. For keeping on using the dll, please contact sales@foxitsoftware.com.");

+		return;

+	}

+	CString strLink = _T("");

+	wchar_t *pBuf = NULL;

+	if(m_pLink != NULL)

+	{

+		FPDFLink_CloseWebLinks(m_pLink);

+		m_pLink = NULL;

+	}

+	m_pLink = FPDFLink_LoadWebLinks(m_pTextPage);

+	if(m_pLink == NULL) return;

+

+	int nCount = FPDFLink_CountWebLinks(m_pLink);

+	if (nCount == 0) return;

+	if (m_rtArray.GetSize()!=0)

+	{

+		m_rtArray.RemoveAll();

+	}

+	for (int i=0; i<nCount; i++)

+	{

+		int nlen = FPDFLink_GetURL(m_pLink, i, NULL, 0)+1;

+		pBuf = new wchar_t[nlen];

+		memset(pBuf, 0, nlen*sizeof(wchar_t));

+		FPDFLink_GetURL(m_pLink, i, (unsigned short*)pBuf, nlen);

+		pBuf[nlen-1] = L'\0';

+		int n = WideCharToMultiByte(CP_ACP, 0, pBuf, -1, NULL, NULL, NULL, NULL);

+		char *p = new char[n];

+		memset(p, 0, n);

+		WideCharToMultiByte(CP_ACP, 0, pBuf, nlen, p, n, NULL, NULL);

+		p[n-1] = '\0';

+		strLink += p;

+		strLink += "\r\n";

+		delete []pBuf;

+		delete []p;

+		int nRects = FPDFLink_CountRects(m_pLink, i);

+		for (int j=0; j<nRects; j++)

+		{

+			PDFRect rect;

+			FPDFLink_GetRect(m_pLink, i, j, 

+				&rect.m_dbLeft, &rect.m_dbTop, &rect.m_dbRight, &rect.m_dbBottom);

+			m_rtArray.Add(rect);

+		}

+	}

+	CDC *pDC = GetDC();

+	DrawAllRect(pDC);

+	ReleaseDC(pDC);

+

+	MessageBox(strLink, "Web Links in this page");

+	

+}

+

+void CReaderVCView::OnInitialUpdate() 

+{

+	CView::OnInitialUpdate();

+

+	// TODO: Add your specialized code here and/or call the base class

+}

+

+void CReaderVCView::OnDestroy() 

+{

+	CView::OnDestroy();

+	// TODO: Add your message handler code here

+}

+

+void CReaderVCView::OnUpdateDocFirstpage(CCmdUI* pCmdUI) 

+{

+	if (0 == m_nPageIndex)

+	{

+		pCmdUI->Enable(FALSE);

+	} 

+	else

+	{

+		pCmdUI->Enable(TRUE);

+	}

+	

+}

+

+void CReaderVCView::OnUpdateDocLastpage(CCmdUI* pCmdUI) 

+{

+	if (m_nPageIndex == m_nTotalPage - 1)

+	{

+		pCmdUI->Enable(FALSE);

+	} 

+	else

+	{

+		pCmdUI->Enable(TRUE);

+	}

+	

+}

+

+void CReaderVCView::OnUpdateDocNextpage(CCmdUI* pCmdUI) 

+{

+	if (m_nPageIndex == m_nTotalPage - 1)

+	{

+		pCmdUI->Enable(FALSE);

+	} 

+	else

+	{

+		pCmdUI->Enable(TRUE);

+	}

+	

+}

+

+void CReaderVCView::OnUpdateDocPrepage(CCmdUI* pCmdUI) 

+{

+	if (0 == m_nPageIndex)

+	{

+		pCmdUI->Enable(FALSE);

+	} 

+	else

+	{

+		pCmdUI->Enable(TRUE);

+	}

+	

+}

+

+void CReaderVCView::OnUpdateToolHand(CCmdUI* pCmdUI) 

+{

+	// TODO: Add your command update UI handler code here

+	if (m_bHand)

+	{

+		pCmdUI->SetCheck(1);

+	} 

+	else

+	{

+		pCmdUI->SetCheck(0);

+	}

+	

+	

+}

+

+void CReaderVCView::OnUpdateToolSnapshot(CCmdUI* pCmdUI) 

+{

+	if (m_bSnap)

+	{

+		pCmdUI->SetCheck(1);

+	} 

+	else

+	{

+		pCmdUI->SetCheck(0);

+	}

+	

+}

+

+void CReaderVCView::OnUpdateToolSelect(CCmdUI* pCmdUI) 

+{

+	if (m_bSelect)

+	{

+		pCmdUI->SetCheck(1);

+	} 

+	else

+	{

+		pCmdUI->SetCheck(0);

+	}

+	

+}

+

+void CReaderVCView::OnViewBookmark() 

+{

+	// TODO: Add your command handler code here

+	CChildFrame* pParent = (CChildFrame*)GetParentFrame();

+	if(pParent == NULL) return;

+	if (m_bBookmark) {

+		pParent->m_wndSplitter.ShowColumn();

+		

+	}else{

+		pParent->m_wndSplitter.HideColumn(0);

+	}

+	m_bBookmark = !m_bBookmark;

+}

+

+

+

+BOOL CReaderVCView::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 

+{

+	ScreenToClient(&pt);

+	// TODO: Add your message handler code here and/or call default

+	double page_x = 0;

+	double page_y = 0;

+	DeviceToPage(pt, page_x, page_y);

+	

+	if(m_pApp)

+	{

+// 		FPDF_BOOL b= FORM_OnMouseWheel(m_pApp, m_pPage,ComposeFlag(),0,zDelta,page_x, page_y);

+// 		if(b)

+// 			return TRUE;

+	}

+	

+	int curPosY = 0;

+	int prevPosY = 0;

+	int distanceY = 25;

+	if(zDelta > 0)

+	{

+		curPosY = GetScrollPos(SB_VERT);

+		prevPosY = SetScrollPos(SB_VERT, curPosY - distanceY, TRUE);

+		curPosY = GetScrollPos(SB_VERT);

+		distanceY = prevPosY - curPosY;

+		m_nStartY = m_nStartY + distanceY;

+		ScrollWindow(0, distanceY);		

+	}

+	else

+	{

+		curPosY = GetScrollPos(SB_VERT);

+		prevPosY = SetScrollPos(SB_VERT, curPosY + distanceY, TRUE);

+		curPosY = GetScrollPos(SB_VERT);

+		distanceY = curPosY - prevPosY;

+		m_nStartY = m_nStartY - distanceY;

+		ScrollWindow(0, -distanceY);

+	}	

+	return CView::OnMouseWheel(nFlags, zDelta, pt);

+}

+

+void CReaderVCView::OnContextMenu(CWnd* pWnd, CPoint point) 

+{

+	

+}

+

+void CReaderVCView::OnEditCopy() 

+{

+

+	if(m_pTextPage == NULL)

+	{

+		AfxMessageBox("Sorry, the fpdftext.dll may has expired. For keeping on using the dll, please contact sales@foxitsoftware.com.");

+		return;

+	}

+	long left = 0;

+	long top = 0;

+	long right = 0;

+	long bottom = 0;

+	LPWSTR pBuff = NULL;

+	int buflen = 0;

+	CString csCopyText;

+

+	if(m_rtArray.GetSize() != 0)

+	{

+		for (int i=0; i<m_rtArray.GetSize(); i++)

+		{

+			PDFRect rect = m_rtArray.GetAt(i);

+			buflen = FPDFText_GetBoundedText(m_pTextPage, rect.m_dbLeft, rect.m_dbTop, rect.m_dbRight,

+				rect.m_dbBottom, (unsigned short*)pBuff, 0) + 1;

+			if(buflen == 0)

+				return;

+			pBuff = new wchar_t[2*buflen];

+			memset(pBuff, 0, 2*buflen);

+

+			FPDFText_GetBoundedText(m_pTextPage, rect.m_dbLeft, rect.m_dbTop, rect.m_dbRight, 

+				rect.m_dbBottom, (unsigned short*)pBuff, buflen);

+

+			int n = WideCharToMultiByte(CP_ACP, 0, pBuff, -1, NULL, NULL, NULL, NULL);

+			char *p = new char[n];

+			memset(p, 0, n);

+			WideCharToMultiByte(CP_ACP, 0, pBuff, buflen, p, n, NULL, NULL);

+			csCopyText = csCopyText + CString(p);

+			delete[] p;

+		}

+		

+		::OpenClipboard(NULL);

+		::EmptyClipboard();

+		HANDLE hClip=GlobalAlloc(GMEM_MOVEABLE,csCopyText.GetLength()+1);

+		char* pBuf=(char*)GlobalLock(hClip); 

+		strcpy(pBuf,csCopyText);

+		GlobalUnlock(hClip);

+		HANDLE hSuccess = SetClipboardData(CF_TEXT, hClip);

+		if(NULL != hSuccess)

+			AfxMessageBox("copy success!");

+		::CloseClipboard();

+		

+

+	}

+	

+}

+

+void CReaderVCView::OnRenderbitmap() 

+{

+

+}

+

+void CReaderVCView::OnExportPdfToBitmap() 

+{

+	if (!m_pExportPageDlg)

+	{

+		m_pExportPageDlg=new CExportPage;

+		m_pExportPageDlg->Create(IDD_EXPORT_PAGE,this);

+		m_pExportPageDlg->InitDialogInfo(this);

+		m_pExportPageDlg->ShowWindow(SW_SHOW);

+	}

+	else

+		m_pExportPageDlg->ShowWindow(SW_SHOW);

+}

+

+BOOL CReaderVCView::PreTranslateMessage(MSG* pMsg) 

+{

+	// TODO: Add your specialized code here and/or call the base class

+// 	PP_Event event;

+// 	if(pMsg->message == WM_LBUTTONDOWN)

+// 	{

+// 		event.type = PP_Event_Type_MouseDown;

+// 		

+// 		int xPos = (int)(WORD)(pMsg->lParam); 

+// 		int yPos = (int)(WORD)((pMsg->lParam >> 16) & 0xFFFF); 

+// 		

+// 		event.u.mouse.x = xPos;

+// 		event.u.mouse.y = yPos;

+// 		FPDF_FormFillEventMsg(m_pPage, event);

+// 	}

+// 	if(pMsg->message == WM_LBUTTONUP)

+// 	{

+// 		event.type = PP_Event_Type_MouseUp;

+// 		

+// 		int xPos = (int)(WORD)(pMsg->lParam); 

+// 		int yPos = (int)(WORD)((pMsg->lParam >> 16) & 0xFFFF); 

+// 		

+// 		event.u.mouse.x = xPos;

+// 		event.u.mouse.y = yPos;

+// 		FPDF_FormFillEventMsg(m_pPage, event);

+// 	}

+	return CView::PreTranslateMessage(pMsg);

+}

+

+void CReaderVCView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 

+{

+	// TODO: Add your message handler code here and/or call default

+	if(m_pApp)

+	{

+		if(FORM_OnChar(m_pApp, m_pPage, nChar, ComposeFlag()))

+			return ;

+	}

+	CView::OnChar(nChar, nRepCnt, nFlags);

+}

+

+void CReaderVCView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView) 

+{

+	// TODO: Add your specialized code here and/or call the base class

+	((CReaderVCApp*)AfxGetApp())->m_pActiveView = (CReaderVCView*)pActivateView;

+	CView::OnActivateView(bActivate, pActivateView, pDeactiveView);

+}

+

+void CReaderVCView::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) 

+{

+	// TODO: Add your message handler code here and/or call default

+	if(m_pApp)

+		FORM_OnKeyUp(m_pApp, m_pPage, nChar, ComposeFlag());

+	CView::OnKeyUp(nChar, nRepCnt, nFlags);

+}

+

+

+int		G_WriteBlock( FPDF_FILEWRITE* pThis, const void* pData, unsigned long size);

+class CSDK_FileWrite:public FPDF_FILEWRITE

+{

+public:

+	CSDK_FileWrite()

+	{

+		m_fp = NULL;

+		version = 0;

+		WriteBlock = G_WriteBlock;

+	}

+public:

+	FILE* m_fp;

+};

+int		G_WriteBlock( FPDF_FILEWRITE* pThis, const void* pData, unsigned long size)

+{

+	CSDK_FileWrite* pFW = (CSDK_FileWrite*)pThis;

+	return fwrite(pData, sizeof(char), size, pFW->m_fp);

+}

+void CReaderVCView::OnFileSave() 

+{

+	// TODO: Add your command handler code here

+	if(m_pDoc != NULL)

+	{

+		CFileDialog dlg(FALSE,"",NULL,NULL,"PDF(*.PDF)|*.PDF||All Files(*.*)|*.*");

+		if (dlg.DoModal() == IDOK)

+		{

+			CString strPDFName = dlg.GetPathName();

+

+			CSDK_FileWrite fw;

+			fw.m_fp = fopen(dlg.GetPathName(), "wb");

+

+			FPDF_SaveAsCopy(m_pDoc, &fw, 0);

+			fclose(fw.m_fp);

+//			FPDF_SaveAsFile(m_pDoc, strPDFName.GetBuffer(strPDFName.GetLength()), 0, NULL, 0, NULL, 0);

+		}		

+	}

+}

+

+

+

+void CReaderVCView::OnTestJS() 

+{

+	// TODO: Add your command handler code here

+	//FPDF_WIDESTRING js = L"run=app.setInterval(\"app.alert(\\\"ok\\\")\");app.setTimeOut(\"app.clearInterval(run)\", 6000);";

+//	FPDF_WIDESTRING js = L"app.alert(AFNumber_Keystroke(\'aaaaaaaaa\'))";

+//	FPDF_WIDESTRING js = L"app.mailMsg(1)";

+	//FPDF_WIDESTRING js = L"app.setTimeOut(\"app.clearInterval(1)\", 6000);";

+	//FPDF_WIDESTRING js = L"t.1";

+//	RunJS(m_pApp, js);

+	CTestJsDlg dlg;

+	dlg.init(m_pApp);

+	dlg.DoModal();

+}

+

+//This function is to simulate the pp event.

+#define PP_EVENT_MODIFIER_SHIFTKEY       1<<0

+#define PP_EVENT_MODIFIER_CONTROLKEY       1<<1

+#define PP_EVENT_MODIFIER_ALTKEY           1<<2

+unsigned int CReaderVCView::ComposeFlag()

+{

+	unsigned int nFlag = 0;

+	if(IsALTpressed())

+		nFlag = nFlag|PP_EVENT_MODIFIER_ALTKEY;

+	if(IsCTRLpressed())

+		nFlag = nFlag|PP_EVENT_MODIFIER_CONTROLKEY;

+	if(IsSHIFTpressed())

+		nFlag = nFlag|PP_EVENT_MODIFIER_SHIFTKEY;

+	return nFlag;

+}

+

+void CReaderVCView::OnPrintMetalfile() 

+{

+	FPDF_PAGE page = FPDF_LoadPage(m_pDoc, 0);

+	if (!page) {

+		return;

+	}

+	

+	HDC printer_dc = CreateDC("WINSPOOL", "Microsoft XPS Document Writer", NULL,

+		NULL);

+	if (!printer_dc) {

+		printf("Could not create printer DC\n");

+		return;

+	}

+	DOCINFO di = {0};

+	di.cbSize = sizeof(DOCINFO);

+	di.lpszDocName = "Foxit print test";

+	int job_id = StartDoc(printer_dc, &di);

+	

+	StartPage(printer_dc);

+	

+	SetGraphicsMode(printer_dc, GM_ADVANCED);

+	XFORM xform = {0, 0, 0, 0, 0, 0};

+	xform.eM11 = xform.eM22 = 2;

+	ModifyWorldTransform(printer_dc, &xform, MWT_LEFTMULTIPLY);

+	

+	int dc_width = GetDeviceCaps(printer_dc, PHYSICALWIDTH);

+	int dc_height = GetDeviceCaps(printer_dc, PHYSICALHEIGHT);

+	HDC metafile_dc = CreateEnhMetaFile(printer_dc, NULL, NULL, NULL);

+	XFORM xform1 = {0, 0, 0, 0, 0, 0};

+	xform1.eM11 = xform1.eM22 = 0.5;

+	ModifyWorldTransform(metafile_dc, &xform1, MWT_LEFTMULTIPLY);

+	FPDF_RenderPage(metafile_dc, page, 0, 0, dc_width, dc_height, 0, 0);

+	

+	HENHMETAFILE emf = CloseEnhMetaFile(metafile_dc);

+	

+	ENHMETAHEADER header = {0};

+	GetEnhMetaFileHeader(emf, sizeof(header), &header);

+	

+	PlayEnhMetaFile(printer_dc, emf, (RECT *)&header.rclBounds);

+	

+	EndPage(printer_dc);

+	EndDoc(printer_dc);

+	

+	DeleteEnhMetaFile(emf);

+	DeleteDC(printer_dc);

+	

+}

+

+void CReaderVCView::CreateLocalPath(CString &csPath)

+{

+	csPath = "c://test.pdf";

+}

+

+BOOL CReaderVCView::HttpDataPost(CString csData, CString csAppName, CString csObject, CString csServer, CString csUserName, CString csPassword, INTERNET_PORT nPort , BOOL IsHTTPS, CString csContentType, CString csAddHeader, CString &csResponse)

+{

+	DWORD retCode = 0;

+	BOOL bRet = FALSE;

+	TRY

+	{

+		CInternetSession sess(csAppName);

+		CHttpConnection* pConnect = sess.GetHttpConnection(csServer, nPort, csUserName, csPassword);

+		if (pConnect == NULL)

+			return FALSE;

+

+		DWORD dwRequestFlags = INTERNET_FLAG_EXISTING_CONNECT;

+		if ( IsHTTPS == TRUE) 

+			dwRequestFlags |= INTERNET_FLAG_SECURE;

+		CHttpFile* pHttpFile = pConnect->OpenRequest(CHttpConnection::HTTP_VERB_POST, csObject, NULL, 1, NULL, NULL, dwRequestFlags);

+		if (pHttpFile != NULL)

+		{

+			CString strData = csData;

+			DWORD dwLength = strData.GetLength();

+

+			CString strHeaders;

+			strHeaders.Format("Content-Type: %s\r\nContent-Length: %d\r\n", csContentType, dwLength);

+			strHeaders += csAddHeader;

+			pHttpFile->AddRequestHeaders(strHeaders);

+			DWORD dwTotalLength = dwLength + strHeaders.GetLength();

+

+resend:

+			bRet = pHttpFile->SendRequestEx(dwTotalLength);

+			pHttpFile->Write(csData, dwLength);

+

+			pHttpFile->QueryInfoStatusCode( retCode );

+			if (HTTP_STATUS_OK == retCode) //succ

+			{

+				char buf[4096] = {0};

+				UINT bytesRead = 0;

+				while( ( bytesRead = pHttpFile->Read( buf, 4095 ) ) > 0 )

+				{

+					buf[bytesRead] = '\0';

+					size_t aLen = strlen( buf ) + 1; 

+					int wLen = MultiByteToWideChar( 936, 0, buf, aLen, NULL, 0 );

+

+					LPOLESTR lpw = new WCHAR [wLen]; 

+					MultiByteToWideChar( 936, 0, buf, aLen, lpw, wLen ); 

+					csResponse += lpw;

+					delete [] lpw; 

+

+					memset( buf, 0, 4096 );

+				} 

+			}

+			bRet = pHttpFile->EndRequest();

+			if (bRet)

+			{

+				// Handle any authentication dialogs.

+				if (NeedAuth(pHttpFile))

+				{

+					DWORD dwErr;

+					dwErr = pHttpFile->ErrorDlg(GetDesktopWindow(),                                                  

+						bRet ? ERROR_SUCCESS : GetLastError(),                         

+						FLAGS_ERROR_UI_FILTER_FOR_ERRORS  |     

+						FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS |

+						FLAGS_ERROR_UI_FLAGS_GENERATE_DATA, 

+						NULL);

+					if (dwErr == ERROR_INTERNET_FORCE_RETRY)

+					{

+						goto resend;

+					}

+					else if(dwErr == 0)

+					{

+						bRet = FALSE;

+					}

+				}

+			}

+			pHttpFile->Close();

+			delete pHttpFile;

+		}

+		pConnect->Close();

+		delete pConnect;

+		sess.Close();

+	}

+	CATCH_ALL(e)

+	{

+		return FALSE;

+	}

+	END_CATCH_ALL

+		return bRet;

+}

+

+BOOL CReaderVCView::HttpDataPut(CString csData, CString csAppName, CString csObject, CString csServer, CString csUserName, CString csPassword, INTERNET_PORT nPort, BOOL IsHTTPS)

+{

+	DWORD retCode = 0;

+	BOOL bRet = FALSE;

+	TRY

+	{

+		CInternetSession sess(csAppName);

+		CHttpConnection* pConnect = sess.GetHttpConnection(csServer, nPort, csUserName, csPassword);

+		if (pConnect == NULL)

+			return FALSE;

+

+		DWORD dwRequestFlags=INTERNET_FLAG_EXISTING_CONNECT;

+		if ( IsHTTPS== TRUE) 

+			dwRequestFlags |= INTERNET_FLAG_SECURE;

+		CHttpFile* pHttpFile = pConnect->OpenRequest(CHttpConnection::HTTP_VERB_PUT, csObject,NULL,1,NULL,NULL,dwRequestFlags);

+		if (pHttpFile != NULL)

+		{

+resend:

+			CString strData = csData;

+			DWORD dwTotalLength = strData.GetLength();

+

+			bRet = pHttpFile->SendRequestEx(dwTotalLength);

+			pHttpFile->Write(csData, dwTotalLength);

+			bRet = pHttpFile->EndRequest();

+			if (bRet)

+			{

+				// Handle any authentication dialogs.

+				if (NeedAuth(pHttpFile))

+				{

+					DWORD dwErr;

+					dwErr = pHttpFile->ErrorDlg(GetDesktopWindow(),

+						bRet ? ERROR_SUCCESS : GetLastError(),                         

+						FLAGS_ERROR_UI_FILTER_FOR_ERRORS  |     

+						FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS |

+						FLAGS_ERROR_UI_FLAGS_GENERATE_DATA, 

+						NULL

+						);

+					if (dwErr == ERROR_INTERNET_FORCE_RETRY)

+					{

+						goto resend;

+					}

+					else if(dwErr == 0)

+					{

+						bRet = FALSE;

+					}

+				}

+			}

+			pHttpFile->QueryInfoStatusCode( retCode );

+			if (retCode != HTTP_STATUS_OK)

+			{

+				bRet = FALSE;

+			}

+			else

+				bRet = TRUE;

+

+			pHttpFile->Close();

+			delete pHttpFile;

+		}

+		pConnect->Close();

+		delete pConnect;

+		sess.Close();

+	}

+	CATCH_ALL(e)

+	{

+		return FALSE;

+	}

+	END_CATCH_ALL

+		return bRet;

+}

+

+BOOL CReaderVCView::NeedAuth(CHttpFile *pHttpFile)

+{

+	// Get status code.

+	DWORD dwStatus;

+	DWORD cbStatus = sizeof(dwStatus);

+	pHttpFile->QueryInfo

+		(

+		HTTP_QUERY_FLAG_NUMBER | HTTP_QUERY_STATUS_CODE,

+		&dwStatus,

+		&cbStatus,

+		NULL

+		);

+	//    fprintf (stderr, "Status: %d\n", dwStatus);

+	// Look for 401 or 407.

+	DWORD dwFlags;

+	switch (dwStatus)

+	{

+	case HTTP_STATUS_DENIED:

+		dwFlags = HTTP_QUERY_WWW_AUTHENTICATE;

+		break;

+	case HTTP_STATUS_PROXY_AUTH_REQ:

+		dwFlags = HTTP_QUERY_PROXY_AUTHENTICATE;

+		break;            

+	default:

+		return FALSE;

+	}

+	// Enumerate the authentication types.

+	BOOL fRet;

+	char szScheme[64];

+	DWORD dwIndex = 0;

+	do

+	{

+		DWORD cbScheme = sizeof(szScheme);

+		fRet = pHttpFile->QueryInfo

+			(dwFlags, szScheme, &cbScheme, &dwIndex);

+

+		//if (fRet)

+		//fprintf (stderr, "Found auth scheme: %s\n", szScheme);

+	}

+	while (fRet);

+	return TRUE;

+}
\ No newline at end of file