Home | History | Annotate | Download | only in src 
      1 // Copyright 2014 PDFium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
      6 
      7 #include "../../public/fpdf_ext.h"
      8 #include "../include/fsdk_define.h"
      9 #include "../include/fsdk_mgr.h"
     10 #include "../include/formfiller/FFL_FormFiller.h"
     11 #include "../include/javascript/IJavaScript.h"
     12 
     13 #if _FX_OS_ == _FX_ANDROID_
     14 #include "time.h"
     15 #else
     16 #include <ctime>
     17 #endif
     18 
     19 //extern CPDFDoc_Environment* g_pFormFillApp;
     20 class CFX_SystemHandler:public IFX_SystemHandler
     21 {
     22 public:
     23 	CFX_SystemHandler(CPDFDoc_Environment* pEnv):m_pEnv(pEnv),m_nCharSet(-1) {}
     24 public:
     25 	virtual void				InvalidateRect(FX_HWND hWnd, FX_RECT rect) ;
     26 	virtual void				OutputSelectedRect(void* pFormFiller, CPDF_Rect& rect);
     27 
     28 	virtual FX_BOOL				IsSelectionImplemented();
     29 
     30 	virtual CFX_WideString		GetClipboardText(FX_HWND hWnd){return L"";}
     31 	virtual FX_BOOL				SetClipboardText(FX_HWND hWnd, CFX_WideString string) {return FALSE;}
     32 
     33 	virtual void				ClientToScreen(FX_HWND hWnd, FX_INT32& x, FX_INT32& y) {}
     34 	virtual void				ScreenToClient(FX_HWND hWnd, FX_INT32& x, FX_INT32& y) {}
     35 
     36 	/*cursor style
     37 	FXCT_ARROW
     38 	FXCT_NESW
     39 	FXCT_NWSE
     40 	FXCT_VBEAM
     41 	FXCT_HBEAM
     42 	FXCT_HAND
     43 	*/
     44 	virtual void				SetCursor(FX_INT32 nCursorType);
     45 
     46 	virtual FX_HMENU			CreatePopupMenu() {return NULL;}
     47 	virtual FX_BOOL				AppendMenuItem(FX_HMENU hMenu, FX_INT32 nIDNewItem, CFX_WideString string) {return FALSE;}
     48 	virtual FX_BOOL				EnableMenuItem(FX_HMENU hMenu, FX_INT32 nIDItem, FX_BOOL bEnabled) {return FALSE;}
     49 	virtual FX_INT32			TrackPopupMenu(FX_HMENU hMenu, FX_INT32 x, FX_INT32 y, FX_HWND hParent) {return -1;}
     50 	virtual void				DestroyMenu(FX_HMENU hMenu) {}
     51 
     52 	virtual CFX_ByteString		GetNativeTrueTypeFont(FX_INT32 nCharset);
     53 	virtual FX_BOOL				FindNativeTrueTypeFont(FX_INT32 nCharset, CFX_ByteString sFontFaceName);
     54 	virtual CPDF_Font*			AddNativeTrueTypeFontToPDF(CPDF_Document* pDoc, CFX_ByteString sFontFaceName, FX_BYTE nCharset);
     55 
     56 	virtual FX_INT32			SetTimer(FX_INT32 uElapse, TimerCallback lpTimerFunc) ;
     57 	virtual void				KillTimer(FX_INT32 nID) ;
     58 
     59 
     60 	virtual FX_BOOL				IsSHIFTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsSHIFTKeyDown(nFlag);}
     61 	virtual FX_BOOL				IsCTRLKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsCTRLKeyDown(nFlag);}
     62 	virtual FX_BOOL				IsALTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsALTKeyDown(nFlag);}
     63 	virtual FX_BOOL				IsINSERTKeyDown(FX_DWORD nFlag) {return m_pEnv->FFI_IsINSERTKeyDown(nFlag);}
     64 
     65 	virtual	FX_SYSTEMTIME		GetLocalTime();
     66 
     67 	virtual FX_INT32			GetCharSet() {return m_nCharSet;}
     68 	virtual void 				SetCharSet(FX_INT32 nCharSet) {m_nCharSet = nCharSet;}
     69 private:
     70 	CPDFDoc_Environment* m_pEnv;
     71 	int		m_nCharSet;
     72 };
     73 
     74 void CFX_SystemHandler::SetCursor(FX_INT32 nCursorType)
     75 {
     76 
     77 	m_pEnv->FFI_SetCursor(nCursorType);
     78 }
     79 
     80 void CFX_SystemHandler::InvalidateRect(FX_HWND hWnd, FX_RECT rect)
     81 {
     82 	//g_pFormFillApp->FFI_Invalidate();
     83 	CPDFSDK_Annot* pSDKAnnot = (CPDFSDK_Annot*)hWnd;
     84 	CPDF_Page* pPage = NULL;
     85 	CPDFSDK_PageView* pPageView = NULL;
     86 	pPageView = pSDKAnnot->GetPageView();
     87 	pPage = pSDKAnnot->GetPDFPage();
     88 	if(!pPage || !pPageView)
     89 		return;
     90 	CPDF_Matrix page2device;
     91 	pPageView->GetCurrentMatrix(page2device);
     92 	CPDF_Matrix device2page;
     93 	device2page.SetReverse(page2device);
     94 	FX_FLOAT left, top, right,bottom;
     95 	device2page.Transform((FX_FLOAT)rect.left, (FX_FLOAT)rect.top, left, top);
     96 	device2page.Transform((FX_FLOAT)rect.right, (FX_FLOAT)rect.bottom, right, bottom);
     97 // 	m_pEnv->FFI_DeviceToPage(pPage, rect.left, rect.top, (double*)&left, (double*)&top);
     98 // 	m_pEnv->FFI_DeviceToPage(pPage, rect.right, rect.bottom, (double*)&right, (double*)&bottom);
     99 	CPDF_Rect rcPDF(left, bottom, right, top);
    100 	rcPDF.Normalize();
    101 
    102 	m_pEnv->FFI_Invalidate(pPage, rcPDF.left, rcPDF.top, rcPDF.right, rcPDF.bottom);
    103 }
    104 void CFX_SystemHandler::OutputSelectedRect(void* pFormFiller, CPDF_Rect& rect)
    105 {
    106 	CFFL_FormFiller* pFFL = (CFFL_FormFiller*)pFormFiller;
    107 	if(pFFL)
    108 	{
    109 		CPDF_Point leftbottom = CPDF_Point(rect.left, rect.bottom);
    110 		CPDF_Point righttop = CPDF_Point(rect.right, rect.top);
    111 		CPDF_Point ptA = pFFL->PWLtoFFL(leftbottom);
    112 		CPDF_Point ptB = pFFL->PWLtoFFL(righttop);
    113 
    114 
    115 		CPDFSDK_Annot* pAnnot  = pFFL->GetSDKAnnot();
    116 		ASSERT(pAnnot);
    117 		CPDF_Page* pPage = pAnnot->GetPDFPage();
    118 		ASSERT(pPage);
    119 		m_pEnv->FFI_OutputSelectedRect(pPage, ptA.x, ptB.y, ptB.x, ptA.y);
    120 	}
    121 
    122 }
    123 
    124 FX_BOOL CFX_SystemHandler::IsSelectionImplemented()
    125 {
    126 	if(m_pEnv)
    127 	{
    128 		FPDF_FORMFILLINFO* pInfo = m_pEnv->GetFormFillInfo();
    129 		if(pInfo && pInfo->FFI_OutputSelectedRect)
    130 			return TRUE;
    131 	}
    132 	return FALSE;
    133 }
    134 
    135 CFX_ByteString CFX_SystemHandler::GetNativeTrueTypeFont(FX_INT32 nCharset)
    136 {
    137 	return "";
    138 }
    139 
    140 FX_BOOL	CFX_SystemHandler::FindNativeTrueTypeFont(FX_INT32 nCharset, CFX_ByteString sFontFaceName)
    141 {
    142 	CFX_FontMgr* pFontMgr = CFX_GEModule::Get()->GetFontMgr();
    143 //	FXFT_Face nFace = pFontMgr->FindSubstFont(sFontFaceName,TRUE,0,0,0,0,NULL);
    144 //	FXFT_Face nFace  = pFontMgr->m_pBuiltinMapper->FindSubstFont(sFontFaceName,TRUE,0,0,0,0,NULL);
    145 
    146 	if(pFontMgr)
    147 	{
    148 		CFX_FontMapper*	pFontMapper = pFontMgr->m_pBuiltinMapper;
    149 		if(pFontMapper)
    150 		{
    151 			int nSize = pFontMapper->m_InstalledTTFonts.GetSize();
    152 			if(nSize ==0)
    153 			{
    154 				pFontMapper->LoadInstalledFonts();
    155 				nSize = pFontMapper->m_InstalledTTFonts.GetSize();
    156 			}
    157 
    158 			for(int i=0; i<nSize; i++)
    159 			{
    160 				if(pFontMapper->m_InstalledTTFonts[i].Compare(sFontFaceName))
    161 					return TRUE;
    162 			}
    163 		}
    164 
    165 	}
    166 
    167 	return FALSE;
    168 // 	pFontMgr->m_FaceMap.Lookup(sFontFaceName,pFont);
    169 // 	return (pFont!=NULL);
    170 }
    171 
    172 static int CharSet2CP(int charset)
    173 {
    174 	if(charset == 128)
    175 		return 932;
    176 	else if(charset == 134)
    177 		return 936;
    178 	else if(charset == 129)
    179 		return 949;
    180 	else if(charset == 136)
    181 		return 950;
    182 	return 0;
    183 }
    184 CPDF_Font* CFX_SystemHandler::AddNativeTrueTypeFontToPDF(CPDF_Document* pDoc, CFX_ByteString sFontFaceName,
    185 														 FX_BYTE nCharset)
    186 {
    187 	if(pDoc)
    188 	{
    189 		CFX_Font* pFXFont = new CFX_Font();
    190 		pFXFont->LoadSubst(sFontFaceName,TRUE,0,0,0,CharSet2CP(nCharset),FALSE);
    191 		CPDF_Font* pFont = pDoc->AddFont(pFXFont,nCharset,FALSE);
    192 		delete pFXFont;
    193 		return pFont;
    194 	}
    195 
    196 	return NULL;
    197 }
    198 
    199 
    200 FX_INT32 CFX_SystemHandler::SetTimer(FX_INT32 uElapse, TimerCallback lpTimerFunc)
    201 {
    202 	return m_pEnv->FFI_SetTimer(uElapse, lpTimerFunc);
    203 }
    204 void CFX_SystemHandler::KillTimer(FX_INT32 nID)
    205 {
    206 	m_pEnv->FFI_KillTimer(nID);
    207 }
    208 
    209 FX_SYSTEMTIME CFX_SystemHandler::GetLocalTime()
    210 {
    211 	return m_pEnv->FFI_GetLocalTime();
    212 }
    213 
    214 
    215 CJS_RuntimeFactory* GetJSRuntimeFactory()
    216 {
    217 	static CJS_RuntimeFactory s_JSRuntimeFactory;
    218 	return &s_JSRuntimeFactory;
    219 }
    220 
    221 CPDFDoc_Environment::CPDFDoc_Environment(CPDF_Document* pDoc) :
    222 	m_pAnnotHandlerMgr(NULL),
    223 	m_pActionHandler(NULL),
    224 	m_pJSRuntime(NULL),
    225 	m_pInfo(NULL),
    226 	m_pSDKDoc(NULL),
    227 	m_pPDFDoc(pDoc),
    228 	m_pIFormFiller(NULL)
    229 {
    230 
    231 	m_pSysHandler = NULL;
    232 	m_pSysHandler = new CFX_SystemHandler(this);
    233 
    234 
    235 	m_pJSRuntimeFactory = NULL;
    236 	m_pJSRuntimeFactory = GetJSRuntimeFactory();
    237 	m_pJSRuntimeFactory->AddRef();
    238 }
    239 
    240 CPDFDoc_Environment::~CPDFDoc_Environment()
    241 {
    242 
    243 	if ( m_pIFormFiller )
    244 	{
    245 		delete m_pIFormFiller;
    246 		m_pIFormFiller = NULL;
    247 	}
    248 	if(m_pJSRuntime && m_pJSRuntimeFactory)
    249 		m_pJSRuntimeFactory->DeleteJSRuntime(m_pJSRuntime);
    250 	m_pJSRuntimeFactory->Release();
    251 
    252 	if(m_pSysHandler)
    253 	{
    254 		delete m_pSysHandler;
    255 		m_pSysHandler = NULL;
    256 	}
    257 
    258 	if(m_pAnnotHandlerMgr)
    259 	{
    260 		delete m_pAnnotHandlerMgr;
    261 		m_pAnnotHandlerMgr = NULL;
    262 	}
    263 	if(m_pActionHandler)
    264 	{
    265 		delete m_pActionHandler;
    266 		m_pActionHandler = NULL;
    267 	}
    268 
    269 
    270 }
    271 
    272 
    273 IFXJS_Runtime* CPDFDoc_Environment::GetJSRuntime()
    274 {
    275 	if(!IsJSInitiated())
    276 		return NULL;
    277 	assert(m_pJSRuntimeFactory);
    278 	if(!m_pJSRuntime)
    279 		m_pJSRuntime = m_pJSRuntimeFactory->NewJSRuntime(this);
    280 	return m_pJSRuntime;
    281 }
    282 
    283 CPDFSDK_AnnotHandlerMgr* CPDFDoc_Environment::GetAnnotHandlerMgr()
    284 {
    285 	if(!m_pAnnotHandlerMgr)
    286 		m_pAnnotHandlerMgr = new CPDFSDK_AnnotHandlerMgr(this);
    287 	return m_pAnnotHandlerMgr;
    288 }
    289 
    290 CPDFSDK_ActionHandler* CPDFDoc_Environment::GetActionHander()
    291 {
    292 	if(!m_pActionHandler)
    293 		m_pActionHandler = new CPDFSDK_ActionHandler(this);
    294 	return m_pActionHandler;
    295 }
    296 
    297 int CPDFDoc_Environment::RegAppHandle(FPDF_FORMFILLINFO* pFFinfo)
    298 {
    299 	m_pInfo  = pFFinfo;
    300 	return TRUE;
    301 }
    302 
    303 CPDFSDK_Document* CPDFDoc_Environment::GetCurrentDoc()
    304 {
    305 	return m_pSDKDoc;
    306 }
    307 
    308 CFFL_IFormFiller* CPDFDoc_Environment::GetIFormFiller()
    309 {
    310 	if(!m_pIFormFiller)
    311 		m_pIFormFiller = new CFFL_IFormFiller(this);
    312 	return m_pIFormFiller;
    313 }
    314 
    315 FX_BOOL	CPDFDoc_Environment::IsJSInitiated()
    316 {
    317 	if(m_pInfo)
    318 	{
    319 		if(m_pInfo->m_pJsPlatform)
    320 			return TRUE;
    321 		else
    322 			return FALSE;
    323 	}
    324 	return FALSE;
    325 }
    326 
    327 CPDFSDK_Document::CPDFSDK_Document(CPDF_Document* pDoc,CPDFDoc_Environment* pEnv):m_pDoc(pDoc),
    328 						m_pInterForm(NULL),m_pEnv(pEnv),m_pOccontent(NULL),m_bChangeMask(FALSE)
    329 {
    330 	m_pFocusAnnot = NULL;
    331 }
    332 
    333 CPDFSDK_Document::~CPDFSDK_Document()
    334 {
    335 	FX_POSITION pos = m_pageMap.GetStartPosition();
    336 	while (pos) {
    337             CPDF_Page* pPage = NULL;
    338             CPDFSDK_PageView* pPageView = NULL;
    339             m_pageMap.GetNextAssoc(pos, pPage, pPageView);
    340             delete pPageView;
    341         }
    342         m_pageMap.RemoveAll();
    343 	if(m_pInterForm)
    344 	{
    345 		m_pInterForm->Destroy();
    346 		m_pInterForm = NULL;
    347 	}
    348 	if(m_pOccontent)
    349 	{
    350 		delete m_pOccontent;
    351 		m_pOccontent = NULL;
    352 	}
    353 }
    354 
    355 void CPDFSDK_Document::InitPageView()
    356 {
    357 	int nCount = m_pDoc->GetPageCount();
    358 	for(int i=0; i<nCount; i++)
    359 	{
    360 	// To do
    361 //		CPDF_Dictionary* pDic = m_pDoc->GetPage(i);
    362 //		m_pageMap.SetAt(pDic, pPageView);
    363 	}
    364 }
    365 
    366 void CPDFSDK_Document::AddPageView(CPDF_Page* pPDFPage, CPDFSDK_PageView* pPageView)
    367 {
    368 	m_pageMap.SetAt(pPDFPage, pPageView);
    369 }
    370 
    371 CPDFSDK_PageView* CPDFSDK_Document::GetPageView(CPDF_Page* pPDFPage, FX_BOOL ReNew)
    372 {
    373 	CPDFSDK_PageView* pPageView = (CPDFSDK_PageView*)m_pageMap.GetValueAt(pPDFPage);
    374 	if(pPageView != NULL)
    375 		return pPageView;
    376 	if(ReNew)
    377 	{
    378 		pPageView = new CPDFSDK_PageView(this,pPDFPage);
    379 		m_pageMap.SetAt(pPDFPage, pPageView);
    380 		//Delay to load all the annotations, to avoid endless loop.
    381 		pPageView->LoadFXAnnots();
    382 	}
    383 	return pPageView;
    384 
    385 }
    386 
    387 CPDFSDK_PageView* CPDFSDK_Document::GetCurrentView()
    388 {
    389 	CPDF_Page * pPage = (CPDF_Page *)m_pEnv->FFI_GetCurrentPage(m_pDoc);
    390 	if(pPage)
    391 		return this->GetPageView(pPage, TRUE);
    392 	return NULL;
    393 }
    394 
    395 CPDFSDK_PageView* CPDFSDK_Document::GetPageView(int nIndex)
    396 {
    397 	CPDFSDK_PageView * pTempPageView = NULL;
    398 	CPDF_Page * pTempPage = (CPDF_Page*)m_pEnv->FFI_GetPage(m_pDoc,nIndex);
    399 	if(!pTempPage)
    400 		return NULL;
    401 
    402 	m_pageMap.Lookup(pTempPage, pTempPageView);
    403 
    404 	ASSERT(pTempPageView != NULL);
    405 
    406 	return pTempPageView;
    407 }
    408 
    409 void CPDFSDK_Document:: ProcJavascriptFun()
    410 {
    411 	CPDF_Document* pPDFDoc = this->GetDocument();
    412 	CPDF_DocJSActions docJS(pPDFDoc);
    413 	int iCount = docJS.CountJSActions();
    414 	if (iCount < 1) return;
    415 	for (int i = 0; i < iCount; i ++)
    416 	{
    417 		CFX_ByteString csJSName;
    418 		CPDF_Action jsAction = docJS.GetJSAction(i, csJSName);
    419 		if(m_pEnv->GetActionHander())
    420 			m_pEnv->GetActionHander()->DoAction_JavaScript(jsAction,CFX_WideString::FromLocal(csJSName),this);
    421 	}
    422 
    423 }
    424 
    425 FX_BOOL CPDFSDK_Document::ProcOpenAction()
    426 {
    427 	if(!m_pDoc)
    428 		return FALSE;
    429 
    430 	CPDF_Dictionary* pRoot = m_pDoc->GetRoot();
    431 	if (!pRoot)
    432 		return FALSE;
    433 
    434 	CPDF_Object* pOpenAction = pRoot->GetDict("OpenAction");
    435 	if(!pOpenAction)
    436 		pOpenAction = pRoot->GetArray("OpenAction");
    437 
    438 	if(!pOpenAction)
    439 		return FALSE;
    440 
    441 	if(pOpenAction->GetType()==PDFOBJ_ARRAY)
    442 		return TRUE;
    443 
    444 	if(pOpenAction->GetType()==PDFOBJ_DICTIONARY)
    445 	{
    446 		CPDF_Dictionary * pDict=(CPDF_Dictionary*)pOpenAction;
    447 		CPDF_Action action(pDict);
    448 		if(m_pEnv->GetActionHander())
    449 			m_pEnv->GetActionHander()->DoAction_DocOpen(action, this);
    450 		return TRUE;
    451 	}
    452 	return FALSE;
    453 }
    454 
    455 CPDF_OCContext*	CPDFSDK_Document::GetOCContext()
    456 {
    457 	if(!m_pOccontent)
    458 		m_pOccontent = new CPDF_OCContext(m_pDoc);
    459 	return m_pOccontent;
    460 }
    461 
    462 void CPDFSDK_Document::ReMovePageView(CPDF_Page* pPDFPage)
    463 {
    464 	CPDFSDK_PageView* pPageView = (CPDFSDK_PageView*)m_pageMap.GetValueAt(pPDFPage);
    465 	if(pPageView && !pPageView->IsLocked())
    466 	{
    467 		delete pPageView;
    468 		m_pageMap.RemoveKey(pPDFPage);
    469 	}
    470 }
    471 
    472 CPDF_Page * CPDFSDK_Document::GetPage(int nIndex)
    473 {
    474 	CPDF_Page * pTempPage = (CPDF_Page*)m_pEnv->FFI_GetPage(m_pDoc,nIndex);
    475 	if(!pTempPage)
    476 		return NULL;
    477 	return pTempPage;
    478 }
    479 
    480 CPDFSDK_InterForm* CPDFSDK_Document::GetInterForm()
    481 {
    482 	if(!m_pInterForm)
    483 		m_pInterForm = new CPDFSDK_InterForm(this);
    484 	return m_pInterForm;
    485 }
    486 
    487 void CPDFSDK_Document::UpdateAllViews(CPDFSDK_PageView* pSender, CPDFSDK_Annot* pAnnot)
    488 {
    489 
    490 	FX_POSITION pos = m_pageMap.GetStartPosition();
    491 	CPDF_Page * pPage = NULL;
    492 	CPDFSDK_PageView * pPageView = NULL;
    493 	while(pos)
    494 	{
    495 		m_pageMap.GetNextAssoc(pos, pPage, pPageView);
    496 
    497 		if(pPageView != pSender)
    498 		{
    499 			pPageView->UpdateView(pAnnot);
    500 		}
    501 	}
    502 }
    503 
    504 CPDFSDK_Annot* CPDFSDK_Document::GetFocusAnnot()
    505 {
    506 	return this->m_pFocusAnnot;
    507 }
    508 
    509 FX_BOOL CPDFSDK_Document::SetFocusAnnot(CPDFSDK_Annot* pAnnot,FX_UINT nFlag)
    510 {
    511 
    512 	if(m_pFocusAnnot==pAnnot) return TRUE;
    513 
    514 	if(m_pFocusAnnot)
    515 	{
    516 		if(!this->KillFocusAnnot(nFlag) ) return FALSE;
    517 	}
    518 	CPDFSDK_PageView* pPageView = pAnnot->GetPageView();
    519 	if(pAnnot && pPageView->IsValid())
    520 	{
    521 		CPDFSDK_AnnotHandlerMgr *pAnnotHandler=m_pEnv->GetAnnotHandlerMgr();
    522 
    523 		if(pAnnotHandler&&!m_pFocusAnnot)
    524 		{
    525 			if (!pAnnotHandler->Annot_OnSetFocus(pAnnot,nFlag))
    526 				return FALSE;
    527 			if(!m_pFocusAnnot)
    528 			{
    529 				this->m_pFocusAnnot=pAnnot;
    530 				return TRUE;
    531 			}
    532 		}
    533 	}
    534 	return FALSE;
    535 }
    536 
    537 FX_BOOL CPDFSDK_Document::KillFocusAnnot(FX_UINT nFlag)
    538 {
    539 	if(m_pFocusAnnot)
    540 	{
    541 		CPDFSDK_AnnotHandlerMgr *pAnnotHandler=m_pEnv->GetAnnotHandlerMgr();
    542 		if(pAnnotHandler)
    543 		{
    544 			CPDFSDK_Annot* pFocusAnnot = m_pFocusAnnot;
    545 			m_pFocusAnnot = NULL;
    546 			if(pAnnotHandler->Annot_OnKillFocus(pFocusAnnot, nFlag))
    547 			{
    548 
    549 				if(pFocusAnnot->GetType() == FX_BSTRC("Widget"))
    550 				{
    551 					CPDFSDK_Widget* pWidget = (CPDFSDK_Widget*)pFocusAnnot;
    552 					int nFieldType = pWidget->GetFieldType();
    553 					if(FIELDTYPE_TEXTFIELD == nFieldType || FIELDTYPE_COMBOBOX == nFieldType)
    554 						m_pEnv->FFI_OnSetFieldInputFocus(NULL, NULL, 0, FALSE);
    555 				}
    556 
    557 				if(!m_pFocusAnnot)
    558 					return TRUE;
    559 			}
    560 			else
    561 			{
    562 				m_pFocusAnnot = pFocusAnnot;
    563 			}
    564 		}
    565 	}
    566 	return FALSE;
    567 }
    568 
    569 FX_BOOL	CPDFSDK_Document::DeletePages(int nStart, int  nCount)
    570 {
    571 	if ( nStart < 0 || nStart >= GetPageCount() || nCount <= 0 )
    572 	{
    573 		return FALSE;
    574 	}
    575 
    576 	CPDF_Page * pTempPage = NULL;
    577 	for ( int i = nCount-1; i >= 0; i-- )
    578 	{
    579 		pTempPage = GetPage(nStart+i);
    580 		if ( pTempPage != NULL )
    581 		{
    582 			ReMovePageView(pTempPage);
    583 		}
    584 	}
    585 	return TRUE;
    586 }
    587 
    588 void CPDFSDK_Document::OnCloseDocument()
    589 {
    590 	KillFocusAnnot();
    591 }
    592 
    593 FX_BOOL CPDFSDK_Document::GetPermissions(int nFlag)
    594 {
    595 	FX_DWORD dwPermissions = m_pDoc->GetUserPermissions();
    596 	return dwPermissions&nFlag;
    597 }
    598 
    599 IFXJS_Runtime * CPDFSDK_Document::GetJsRuntime()
    600 {
    601 	ASSERT(m_pEnv!=NULL);
    602 	return m_pEnv->GetJSRuntime();
    603 }
    604 
    605 CFX_WideString	CPDFSDK_Document::GetPath()
    606 {
    607 	ASSERT(m_pEnv != NULL);
    608 	return m_pEnv->JS_docGetFilePath();
    609 }
    610 
    611 
    612 CPDFSDK_PageView::CPDFSDK_PageView(CPDFSDK_Document* pSDKDoc,CPDF_Page* page):m_page(page),m_pSDKDoc(pSDKDoc)
    613 {
    614 	CPDFSDK_InterForm* pInterForm = pSDKDoc->GetInterForm();
    615 	if(pInterForm)
    616 	{
    617 		CPDF_InterForm* pPDFInterForm = pInterForm->GetInterForm();
    618 		pPDFInterForm->FixPageFields(page);
    619 	}
    620         m_page->SetPrivateData((FX_LPVOID)m_page, (FX_LPVOID)this, NULL);
    621 	m_fxAnnotArray.RemoveAll();
    622 
    623 	m_bEnterWidget = FALSE;
    624 	m_bExitWidget = FALSE;
    625 	m_bOnWidget = FALSE;
    626 	m_CaptureWidget = NULL;
    627 	m_bValid = FALSE;
    628         m_bLocked = FALSE;
    629         m_bTakeOverPage = FALSE;
    630 }
    631 
    632 CPDFSDK_PageView::~CPDFSDK_PageView()
    633 {
    634 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    635 	int nAnnotCount = m_fxAnnotArray.GetSize();
    636 
    637 	for (int i=0; i<nAnnotCount; i++)
    638 	{
    639 		CPDFSDK_Annot* pAnnot = (CPDFSDK_Annot*)m_fxAnnotArray.GetAt(i);
    640 		//if there is a focused annot on the page, we should kill the focus first.
    641 		if(pAnnot == m_pSDKDoc->GetFocusAnnot())
    642 			KillFocusAnnot();
    643 		CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
    644 		ASSERT(pAnnotHandlerMgr);
    645 		pAnnotHandlerMgr->ReleaseAnnot(pAnnot);
    646 	}
    647 	m_fxAnnotArray.RemoveAll();
    648 	if(m_pAnnotList)
    649 	{
    650 		delete m_pAnnotList;
    651 		m_pAnnotList = NULL;
    652 	}
    653         m_page->RemovePrivateData((FX_LPVOID)m_page);
    654         if(m_bTakeOverPage) {
    655             delete m_page;
    656         }
    657 }
    658 
    659 void CPDFSDK_PageView::PageView_OnDraw(CFX_RenderDevice* pDevice, CPDF_Matrix* pUser2Device,CPDF_RenderOptions* pOptions)
    660 {
    661 	m_curMatrix = *pUser2Device;
    662 
    663 	//	m_pAnnotList->DisplayAnnots(m_page, pDevice, pUser2Device, FALSE, pOptions);
    664 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    665 	CPDFSDK_AnnotIterator annotIterator(this, TRUE);
    666 	CPDFSDK_Annot * pSDKAnnot=NULL;
    667 	int index=-1;
    668 	while((pSDKAnnot = annotIterator.Next(index)))
    669 	{
    670 		CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
    671 		ASSERT(pAnnotHandlerMgr);
    672 		pAnnotHandlerMgr->Annot_OnDraw(this, pSDKAnnot, pDevice, pUser2Device, 0);
    673 	}
    674 
    675 }
    676 
    677 CPDF_Annot* CPDFSDK_PageView::GetPDFAnnotAtPoint(FX_FLOAT pageX, FX_FLOAT pageY)
    678 {
    679 
    680 	int nCount = m_pAnnotList->Count();
    681 	for(int i = 0 ; i<nCount; i++)
    682 	{
    683 		CPDF_Annot* pAnnot = m_pAnnotList->GetAt(i);
    684 		CFX_FloatRect annotRect;
    685 		pAnnot->GetRect(annotRect);
    686 		if(annotRect.Contains(pageX, pageY))
    687 			return pAnnot;
    688 	}
    689 	return NULL;
    690 }
    691 
    692 CPDF_Annot* CPDFSDK_PageView::GetPDFWidgetAtPoint(FX_FLOAT pageX, FX_FLOAT pageY)
    693 {
    694 
    695 	int nCount = m_pAnnotList->Count();
    696 	for(int i = 0 ; i<nCount; i++)
    697 	{
    698 		CPDF_Annot* pAnnot = m_pAnnotList->GetAt(i);
    699 		if(pAnnot->GetSubType() == "Widget")
    700 		{
    701 			CFX_FloatRect annotRect;
    702 			pAnnot->GetRect(annotRect);
    703 			if(annotRect.Contains(pageX, pageY))
    704 				return pAnnot;
    705 		}
    706 	}
    707 	return NULL;
    708 }
    709 
    710 CPDFSDK_Annot* CPDFSDK_PageView::GetFXAnnotAtPoint(FX_FLOAT pageX, FX_FLOAT pageY)
    711 {
    712 
    713 	CPDFSDK_AnnotIterator annotIterator(this, FALSE);
    714 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    715 	CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
    716 	CPDFSDK_Annot* pSDKAnnot = NULL;
    717 	int index = -1;
    718 	while((pSDKAnnot = annotIterator.Next(index)))
    719 	{
    720 		CPDF_Rect rc = pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
    721 		if(rc.Contains(pageX, pageY))
    722 			return pSDKAnnot;
    723 	}
    724 
    725 	return NULL;
    726 }
    727 
    728 CPDFSDK_Annot* CPDFSDK_PageView::GetFXWidgetAtPoint(FX_FLOAT pageX, FX_FLOAT pageY)
    729 {
    730 
    731 	CPDFSDK_AnnotIterator annotIterator(this, FALSE);
    732 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    733 	CPDFSDK_AnnotHandlerMgr* pAnnotMgr = pEnv->GetAnnotHandlerMgr();
    734 	CPDFSDK_Annot* pSDKAnnot = NULL;
    735 	int index = -1;
    736 	while((pSDKAnnot = annotIterator.Next(index)))
    737 	{
    738 		if(pSDKAnnot->GetType() == "Widget")
    739 		{
    740 			pAnnotMgr->Annot_OnGetViewBBox(this, pSDKAnnot);
    741 			CPDF_Point point(pageX, pageY);
    742 			if (pAnnotMgr->Annot_OnHitTest(this, pSDKAnnot, point))
    743 //			if(rc.Contains(pageX, pageY))
    744 				return pSDKAnnot;
    745 		}
    746 	}
    747 
    748 	return NULL;
    749 }
    750 
    751 
    752 FX_BOOL CPDFSDK_PageView::Annot_HasAppearance(CPDF_Annot* pAnnot)
    753 {
    754 	CPDF_Dictionary* pAnnotDic = pAnnot->m_pAnnotDict;
    755 	if(pAnnotDic)
    756 		return	pAnnotDic->KeyExist("AS");
    757 	return FALSE;
    758 }
    759 
    760 CPDFSDK_Annot*	CPDFSDK_PageView::AddAnnot(CPDF_Annot * pPDFAnnot)
    761 {
    762 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    763 	ASSERT(pEnv);
    764 	CPDFSDK_AnnotHandlerMgr * pAnnotHandler= pEnv->GetAnnotHandlerMgr();
    765 
    766 	CPDFSDK_Annot* pSDKAnnot =NULL;
    767 
    768 	if(pAnnotHandler)
    769 	{
    770 		pSDKAnnot = pAnnotHandler->NewAnnot(pPDFAnnot, this);
    771 	}
    772 	if(!pSDKAnnot)
    773 		return NULL;
    774 
    775 	m_fxAnnotArray.Add(pSDKAnnot);
    776 
    777 	if(pAnnotHandler)
    778 	{
    779 		pAnnotHandler->Annot_OnCreate(pSDKAnnot);
    780 
    781 	}
    782 
    783 	 return pSDKAnnot;
    784 }
    785 
    786 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(CPDF_Dictionary * pDict)
    787 {
    788 	if(pDict)
    789 		return this->AddAnnot(pDict->GetString("Subtype"),pDict);
    790 	 return NULL;
    791 }
    792 
    793 CPDFSDK_Annot* CPDFSDK_PageView::AddAnnot(FX_LPCSTR lpSubType,CPDF_Dictionary * pDict)
    794 {
    795 	return NULL;
    796 }
    797 
    798 FX_BOOL  CPDFSDK_PageView::DeleteAnnot(CPDFSDK_Annot* pAnnot)
    799 {
    800 	return FALSE;
    801 }
    802 
    803 CPDF_Document* CPDFSDK_PageView::GetPDFDocument()
    804 {
    805 	if(m_page)
    806 	{
    807 		return m_page->m_pDocument;
    808 	}
    809 	return NULL;
    810 }
    811 
    812 int	CPDFSDK_PageView::CountAnnots()
    813 {
    814 	return m_pAnnotList->Count();
    815 }
    816 
    817 CPDFSDK_Annot*	CPDFSDK_PageView::GetAnnot(int nIndex)
    818 {
    819 	int nCount = m_fxAnnotArray.GetSize();
    820 	if ( nIndex < 0 || nIndex >= nCount )
    821 	{
    822 		return NULL;
    823 	}
    824 
    825 	return (CPDFSDK_Annot*)m_fxAnnotArray.GetAt(nIndex);
    826 }
    827 
    828 CPDFSDK_Annot* CPDFSDK_PageView::GetAnnotByDict(CPDF_Dictionary * pDict)
    829 {
    830 	int nCount = m_fxAnnotArray.GetSize();
    831  	for(int i=0; i<nCount; i++)
    832  	{
    833 		CPDFSDK_Annot* pAnnot = (CPDFSDK_Annot*)m_fxAnnotArray.GetAt(i);
    834  		if(pDict==pAnnot->GetPDFAnnot()->m_pAnnotDict)
    835  			return pAnnot;
    836  	}
    837 	return NULL;
    838 }
    839 
    840 FX_BOOL CPDFSDK_PageView::OnLButtonDown(const CPDF_Point & point, FX_UINT nFlag)
    841 {
    842 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    843 	ASSERT(pEnv);
    844 	CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
    845 	if(!pFXAnnot)
    846 	{
    847 		KillFocusAnnot(nFlag);
    848 	}
    849 	else
    850 	{
    851 		CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
    852 		ASSERT(pAnnotHandlerMgr);
    853 
    854 		FX_BOOL bRet = pAnnotHandlerMgr->Annot_OnLButtonDown(this, pFXAnnot, nFlag,point);
    855  		if(bRet)
    856  		{
    857  			SetFocusAnnot(pFXAnnot);
    858  		}
    859 		return bRet;
    860 	}
    861 	return FALSE;
    862 }
    863 
    864 
    865 FX_BOOL CPDFSDK_PageView::OnLButtonUp(const CPDF_Point & point, FX_UINT nFlag)
    866 {
    867 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    868 	ASSERT(pEnv);
    869 	CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
    870 	ASSERT(pAnnotHandlerMgr);
    871 	CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y);
    872 	CPDFSDK_Annot* pFocusAnnot = GetFocusAnnot();
    873 	FX_BOOL bRet  = FALSE;
    874 	if(pFocusAnnot && pFocusAnnot != pFXAnnot)
    875 	{
    876 		//Last focus Annot gets a chance to handle the event.
    877 		bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFocusAnnot, nFlag,point);
    878 	}
    879 	if(pFXAnnot && !bRet)
    880 	{
    881 		bRet = pAnnotHandlerMgr->Annot_OnLButtonUp(this, pFXAnnot, nFlag,point);
    882 		return bRet;
    883 	}
    884 	return bRet;
    885 }
    886 
    887 FX_BOOL CPDFSDK_PageView::OnMouseMove(const CPDF_Point & point, int nFlag)
    888 {
    889 
    890 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    891 	CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
    892 	ASSERT(pAnnotHandlerMgr);
    893 	if(CPDFSDK_Annot* pFXAnnot = GetFXWidgetAtPoint(point.x, point.y))
    894 	{
    895 		if(m_CaptureWidget && m_CaptureWidget != pFXAnnot)
    896 		{
    897 			m_bExitWidget = TRUE;
    898 			m_bEnterWidget = FALSE;
    899 			pAnnotHandlerMgr->Annot_OnMouseExit(this, m_CaptureWidget, nFlag);
    900 		}
    901 		m_CaptureWidget = (CPDFSDK_Widget*)pFXAnnot;
    902 		m_bOnWidget = TRUE;
    903 		if(!m_bEnterWidget)
    904 		{
    905 			m_bEnterWidget = TRUE;
    906 			m_bExitWidget = FALSE;
    907 			pAnnotHandlerMgr->Annot_OnMouseEnter(this, pFXAnnot,nFlag);
    908 		}
    909 		pAnnotHandlerMgr->Annot_OnMouseMove(this, pFXAnnot, nFlag, point);
    910 		return TRUE;
    911 	}
    912 	else
    913 	{
    914 		if(m_bOnWidget)
    915 		{
    916 			m_bOnWidget = FALSE;
    917 			m_bExitWidget = TRUE;
    918 			m_bEnterWidget = FALSE;
    919 			if(m_CaptureWidget)
    920 			{
    921 				pAnnotHandlerMgr->Annot_OnMouseExit(this, m_CaptureWidget, nFlag);
    922 				m_CaptureWidget = NULL;
    923 			}
    924 		}
    925 		return FALSE;
    926 	}
    927 
    928 	return FALSE;;
    929 }
    930 
    931 FX_BOOL CPDFSDK_PageView::OnMouseWheel(double deltaX, double deltaY,const CPDF_Point& point, int nFlag)
    932 {
    933 	if(CPDFSDK_Annot* pAnnot = GetFXWidgetAtPoint(point.x, point.y))
    934 	{
    935 		CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    936 		CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
    937 		ASSERT(pAnnotHandlerMgr);
    938 		return pAnnotHandlerMgr->Annot_OnMouseWheel(this, pAnnot, nFlag, (int)deltaY, point);
    939 	}
    940 	return FALSE;
    941 
    942 }
    943 
    944 FX_BOOL CPDFSDK_PageView::OnChar(int nChar, FX_UINT nFlag)
    945 {
    946 	if(CPDFSDK_Annot* pAnnot = GetFocusAnnot())
    947 	{
    948 		CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    949 		CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
    950 		ASSERT(pAnnotHandlerMgr);
    951 		return pAnnotHandlerMgr->Annot_OnChar(pAnnot, nChar, nFlag);
    952 	}
    953 
    954 	return FALSE;
    955 }
    956 
    957 FX_BOOL CPDFSDK_PageView::OnKeyDown(int nKeyCode, int nFlag)
    958 {
    959 	if(CPDFSDK_Annot* pAnnot = GetFocusAnnot())
    960 	{
    961 		CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    962 		CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
    963 		ASSERT(pAnnotHandlerMgr);
    964 		return pAnnotHandlerMgr->Annot_OnKeyDown(pAnnot, nKeyCode, nFlag);
    965 	}
    966 	return FALSE;
    967 }
    968 
    969 FX_BOOL CPDFSDK_PageView::OnKeyUp(int nKeyCode, int nFlag)
    970 {
    971 // 	if(CPDFSDK_Annot* pAnnot = GetFocusAnnot())
    972 // 	{
    973 // 		CFFL_IFormFiller* pIFormFiller = g_pFormFillApp->GetIFormFiller();
    974 // 		return pIFormFiller->OnKeyUp(pAnnot, nKeyCode, nFlag);
    975 // 	}
    976 	return FALSE;
    977 }
    978 
    979 extern void CheckUnSupportAnnot(CPDF_Document * pDoc, CPDF_Annot* pPDFAnnot);
    980 
    981 void CPDFSDK_PageView::LoadFXAnnots()
    982 {
    983 	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
    984 
    985 	FX_BOOL enableAPUpdate = CPDF_InterForm::UpdatingAPEnabled();
    986 	//Disable the default AP construction.
    987 	CPDF_InterForm::EnableUpdateAP(FALSE);
    988 	m_pAnnotList = new CPDF_AnnotList(m_page);
    989 	CPDF_InterForm::EnableUpdateAP(enableAPUpdate);
    990 	int nCount = m_pAnnotList->Count();
    991         SetLock(TRUE);
    992 	for(int i=0; i<nCount; i++)
    993 	{
    994 		CPDF_Annot* pPDFAnnot = m_pAnnotList->GetAt(i);
    995 		CPDF_Document * pDoc = this->GetPDFDocument();
    996 
    997 		CheckUnSupportAnnot(pDoc, pPDFAnnot);
    998 
    999 		CPDFSDK_AnnotHandlerMgr* pAnnotHandlerMgr = pEnv->GetAnnotHandlerMgr();
   1000 		ASSERT(pAnnotHandlerMgr != NULL);
   1001 
   1002 		if(pAnnotHandlerMgr)
   1003 		{
   1004 			CPDFSDK_Annot* pAnnot = pAnnotHandlerMgr->NewAnnot(pPDFAnnot, this);
   1005 			if(!pAnnot)
   1006 				continue;
   1007 			m_fxAnnotArray.Add(pAnnot);
   1008 
   1009 			pAnnotHandlerMgr->Annot_OnLoad(pAnnot);
   1010 		}
   1011 
   1012 	}
   1013         SetLock(FALSE);
   1014 }
   1015 
   1016 void	CPDFSDK_PageView::UpdateRects(CFX_RectArray& rects)
   1017 {
   1018 	for(int i=0; i<rects.GetSize(); i++)
   1019 	{
   1020 		CPDF_Rect rc = rects.GetAt(i);
   1021 		CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
   1022 		pEnv->FFI_Invalidate(m_page, rc.left, rc.top, rc.right, rc.bottom);
   1023 	}
   1024 }
   1025 
   1026 void CPDFSDK_PageView::UpdateView(CPDFSDK_Annot* pAnnot)
   1027 {
   1028 	CPDF_Rect rcWindow;
   1029 
   1030  	CPDFDoc_Environment* pEnv = m_pSDKDoc->GetEnv();
   1031 // 	CPDFSDK_AnnotHandlerMgr* pAnnotHandler = pEnv->GetAnnotHandlerMgr();
   1032 
   1033 	rcWindow = pAnnot->GetRect();//pAnnotHandler->Annot_OnGetViewBBox(this,pAnnot);
   1034 	pEnv->FFI_Invalidate(m_page, rcWindow.left, rcWindow.top, rcWindow.right, rcWindow.bottom);
   1035 
   1036 }
   1037 
   1038 int CPDFSDK_PageView::GetPageIndex()
   1039 {
   1040 	if(m_page)
   1041 	{
   1042 		CPDF_Dictionary* pDic = m_page->m_pFormDict;
   1043 		CPDF_Document* pDoc = m_pSDKDoc->GetDocument();
   1044 		if(pDoc && pDic)
   1045 		{
   1046 			return pDoc->GetPageIndex(pDic->GetObjNum());
   1047 		}
   1048 	}
   1049 	return -1;
   1050 }
   1051 
   1052 FX_BOOL	CPDFSDK_PageView::IsValidAnnot(FX_LPVOID p)
   1053 {
   1054 	if (p == NULL) return FALSE;
   1055 	int iCount = m_pAnnotList->Count();
   1056 	for (int i = 0; i < iCount; i++)
   1057 	{
   1058 		if (m_pAnnotList->GetAt(i) == p)
   1059 			return TRUE;
   1060 	}
   1061 	return FALSE;
   1062 }
   1063 
   1064 
   1065 CPDFSDK_Annot* CPDFSDK_PageView::GetFocusAnnot()
   1066 {
   1067 	CPDFSDK_Annot* pFocusAnnot = m_pSDKDoc->GetFocusAnnot();
   1068 	if(!pFocusAnnot)
   1069 		return NULL;
   1070 
   1071 	for(int i=0; i<m_fxAnnotArray.GetSize(); i++)
   1072 	{
   1073 		CPDFSDK_Annot* pAnnot = (CPDFSDK_Annot*)m_fxAnnotArray.GetAt(i);
   1074 		if(pAnnot == pFocusAnnot)
   1075 			return pAnnot;
   1076 	}
   1077 	return NULL;
   1078 }
   1079 
   1080