plxbrow.c

mtk wap和mms代码。。适应mtk 25。26平台

/****************************************************************************
* Function	ConfirmInputJumpTo
* Purpose	when left softkey (ok) is pressed
* Params	
* Return	
* Remarks	
\****************************************************************************/
void ConfirmInputJumpTo(void){
	char *strUrl;
	int  nUrlLen;
//	char	*strTempUrl;
	
	
	if(NULL == jumpToBuffer || 0 == (nUrlLen = pfnUnicodeStrlen((const S8*)jumpToBuffer)))
	{
	//	DisplayPopup((U8 *) GetString(STR_ID_PLX_BROW_ERR_INVALIDURL),IMG_ID_PLX_PUBLIC_SUBMENU_POPOK /*IMG_GLOBAL_WARNING*/, 0,UI_POPUP_NOTIFYDURATION_TIME, WARNING_TONE);
		GoBackHistory();
		PLIB_MessageBox(PMBTYPE_WARNING, NULL, (const WCHAR *)GetString(STR_ID_PLX_BROW_ERR_INVALIDURL),UI_POPUP_NOTIFYDURATION_TIME);
		return;
	}
	bWaitBrowViewExKeyEndFlag = FALSE;
	if(TRUE == bIsLinkInput)
	{
		SaveInputLink();
		bIsLinkInput = FALSE;
	}
	/*change the url's charset: jumpToBuffer->strUrl, UCS2->UTF8*/
	if(PLXBROW_URL_NAME_LEN <= nUrlLen)
		nUrlLen = PLXBROW_URL_NAME_LEN -1;
	if(NULL ==(strUrl = PlxAppMalloc(nUrlLen * 3 + 2)))
	{
		GoBackHistory();
		PLIB_MessageBox(PMBTYPE_ERROR, NULL, (const WCHAR *)GetString(STR_ID_PLX_BROW_ERR_MEMORYMALLOC),UI_POPUP_NOTIFYDURATION_TIME);
		return;
	}
			
	PlxWideCharToUTF8((const char *)jumpToBuffer, nUrlLen, strUrl, nUrlLen * 3 + 2);
	pfnUnicodeStrcpy((S8*)jumpToBuffer,(const S8*)"");
/*	nUrlLen = strlen(strUrl);	
	if(7 > nUrlLen || 
		(7 == nUrlLen && 0 != plxBrowStrnicmp((const char*)strUrl,(const char*)"http://",7) &&
		0 != plxBrowStrnicmp((const char*)strUrl,(const char*)"file://", 7)) ||
		(8 <= nUrlLen && 0 != plxBrowStrnicmp((const char*)strUrl,(const char*)"http://",7) &&
		0 != plxBrowStrnicmp((const char*)strUrl,(const char*)"https://", 8) &&
		0 != plxBrowStrnicmp((const char*)strUrl,(const char*)"file://", 7))
	)
	{
		if(NULL ==(strTempUrl = PlxAppMalloc(nUrlLen+8)))
		{
			PlxAppFree(strUrl);
			GoBackHistory();
			PLIB_MessageBox(PMBTYPE_ERROR, NULL, (const WCHAR *)GetString(STR_ID_PLX_BROW_ERR_MEMORYMALLOC),UI_POPUP_NOTIFYDURATION_TIME);
			return;
		}
		strcpy(strTempUrl,"http://");
		if( PLXBROW_URL_NAME_LEN - 7<= nUrlLen)
		{
			strUrl[PLXBROW_URL_NAME_LEN-8] = '\0';
			strcat(strTempUrl,strUrl);
		}
		else 
			strcat(strTempUrl,strUrl);	
	
		EntryOfPlxBrowserView((const char*)strTempUrl);
		PlxAppFree(strTempUrl);
	}
	else	
*/		EntryOfPlxBrowserView((const char*)strUrl);

	PlxAppFree(strUrl);
}


/****************************************************************************
* Function	ExitInputJumpto
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
void ExitInputJumpto(void){
	bWaitBrowViewExKeyEndFlag = FALSE;
	bIsLinkInput = FALSE;
	if(TRUE == IsScreenPresent(SCR_ID_PLX_BROW_VIEW))
		GoBackToHistory(SCR_ID_PLX_BROW_VIEW);
	else
		GoBackHistory();
}


/****************************************************************************
* Function	SaveInputLink
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
static void SaveInputLink(void)
{
	static int  nLastLen = 0;
	int   nWideUrlLen;
	char* pTemp;
	
	if(szOldLinkInput == NULL)
		nLastLen  =  0;
	if(0 == (nWideUrlLen = pfnUnicodeStrlen((const S8*)jumpToBuffer)))
	{
		if(NULL != szOldLinkInput)
		{
			PlxAppFree(szOldLinkInput);
			szOldLinkInput = NULL;
			nLastLen = 0;
		}
		return;
	}
	else 
	{
		if(NULL == (pTemp = PlxAppRealloc (szOldLinkInput, (nWideUrlLen + 1) * 2)))
		{
			if(nLastLen > nWideUrlLen *2 + 2 &&  szOldLinkInput != NULL)
			{
				pfnUnicodeStrcpy((S8*)szOldLinkInput, (const S8*)jumpToBuffer);
			}
			else
			{
				if(szOldLinkInput)
					PlxAppFree(szOldLinkInput);
				nLastLen = 0;
			}
		}
		else
		{
			szOldLinkInput = pTemp;
			pfnUnicodeStrcpy((S8*)szOldLinkInput, (const S8*)jumpToBuffer);
			nLastLen = nWideUrlLen * 2 + 2;
		}
	}
}


/****************************************************************************
* Function	PlxBrowSetExittingStatus
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
void PlxBrowSetExittingStatus(BOOL bInExitting)
{
	bInExittingStatus = bInExitting;
}


/****************************************************************************
* Function	IsBrowserWaittingStart
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
BOOL IsBrowserWaittingStart(void)
{
	if( BROWSER_START_WAIT_EXIT== nBrowserStatus)
		return TRUE;
	else 
		return FALSE ;
}


/****************************************************************************
* Function	WaittingStartPlxBrowser
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
void WaittingStartPlxBrowser(void)
{
/*	if(BROWSER_RESTART_WAIT_EXIT == nBrowserStatus && NULL == plxBrowInfo.hBrow)
	{
		PlxBrowResetSettingChangeFlag();//may be restart again
		nBrowserStatus = BROWSER_START_WAIT_EXIT;
	}
	if(TRUE == bInExittingStatus )
*/	{	
		PlxBrowResetSettingChangeFlag();//may be restart again
		nBrowserStatus = BROWSER_START_WAIT_EXIT;
#ifdef __PLXBROW_DEBUG_
		PlxTrace("[%d]  WaittingStartPlxBrowser -----> waiting  start the browser!", __LINE__);
#endif
		pixtel_UI_cancel_timer(StartPlxBrowser);
		pixtel_UI_start_timer(PLXBROW_EXITTING_TIMER_DELAY,StartPlxBrowser);
	}
//	else
//		StartPlxBrowser();
}


/****************************************************************************
* Function	WaitingRestartBrowser
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
void WaitingRestartBrowser(void)
{
#ifndef __PLXBROW_SWITCH_PROTOCOL_
	pixtel_UI_cancel_timer(StartPlxBrowser);
	pixtel_UI_start_timer(PLXBROW_EXITTING_TIMER_DELAY, StartPlxBrowser);
	nBrowserStatus = BROWSER_RESTART_WAIT_EXIT;
#endif 
}

/****************************************************************************
* Function	StartPlxBrowser
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
void StartPlxBrowser(void)
{
	WB_PAGEINFO pageInfo;
#if 0	
	static  int nCount = 0;
	
#ifdef __PLXBROW_DEBUG_
 	if(nCount == 0)
		PlxTrace("%s : %d  start timer >>first in start timer>>>>>",__FILE__, __LINE__);
#endif

	nCount ++;
	if(nCount > PLXBROW_FORCE_RESET_EXITFLAG_DELAY)
	{
//		nCount = 0;
		PlxBrowSetExittingStatus(FALSE);
	}
	if(TRUE == bInExittingStatus)
	{
#ifdef __PLXBROW_DEBUG_	
	PlxTrace("%s : %d  start timer >>>>> waitting in timer [%d]>>>>>",__FILE__, __LINE__, nCount);
#endif
		pixtel_UI_cancel_timer(StartPlxBrowser);
		pixtel_UI_start_timer(PLXBROW_EXITTING_TIMER_DELAY,StartPlxBrowser);
		return;
	}
#ifdef __PLXBROW_DEBUG_	
	PlxTrace("%s : %d  start timer >>>>>>> exit waitting mode >>>>>",__FILE__, __LINE__);
#endif
	nCount = 0;
#endif

#ifdef __PLXBROW_DEBUG_	
	PlxTrace("[%d]  StartPlxBrowser ----->Init Engine", __LINE__);
#endif

	pixtel_UI_cancel_timer(StartPlxBrowser);
	InitPlxBrowserEngine();
	InitPlxBrowserEngineOption();
	
	if(SCR_ID_PLX_BROW_VIEW == GetExitScrnID())
	{
//		PlxAppMemcpy(pWebPageTitle, "\x20\x00\x00\x00", 4);
		pfnUnicodeStrcpy((S8*)pWebPageTitle, (const S8*)get_string(STR_ID_PLX_BROW));
		MMI_title_string = (UI_string_type)pWebPageTitle;
		draw_title();

#ifndef __PLXBROW_LOGO_NOSCROLL_		
		pageInfo.nMax = 1;
		pageInfo.nPage = 1;
		pageInfo.nPos = 1;
#ifndef __PLXBROW_DYNCSHOW_HSCROLL_		
		PWBCBSetScrollPosProc(0, WBSBT_HORZ, &pageInfo, WBSBS_ENABLE);
#else
		PWBCBSetScrollPosProc(0, WBSBT_HORZ, &pageInfo, WBSBS_DISABLE);
#endif

#ifndef __PLXBROW_DYNCSHOW_VSCROLL_
		PWBCBSetScrollPosProc(0, WBSBT_VERT, &pageInfo, WBSBS_ENABLE);
#else
		PWBCBSetScrollPosProc(0, WBSBT_VERT, &pageInfo, WBSBS_DISABLE);
#endif
#endif // __PLXBROW_LOGO_NOSCROLL_		

		PWBDrawBrowserWaitingImage();
	}

	if(BROWSER_START_WAIT_EXIT == nBrowserStatus)
	{
		if(NULL != szTempSavedUrl)
		{
			PlxBrowOpenWebPage(szTempSavedUrl);
#ifdef __PLXBROW_SWITCH_PROTOCOL_
			PlxAppFree(szTempSavedUrl);
			szTempSavedUrl = NULL;
			nTempSavedUrlLen = 0;
#endif
		}
		nBrowserStatus = BROWSER_NORMAL;
	}
#ifndef __PLXBROW_SWITCH_PROTOCOL_
	else if(TRUE== PlxBrowIsBrowserNeedRestart())
	{
		
		nBrowserStatus = BROWSER_NORMAL;
		PlxBrowResetSettingChangeFlag();
		if(NULL != szTempSavedUrl)
		{
			PlxBrowOpenWebPage(szTempSavedUrl);
//			PlxAppFree(szTempSavedUrl);
//			szTempSavedUrl = NULL;
		}
		else
		{
			PlxBrowOpenWebPage((char *)"http://"); //just for showing read info
//			PLIB_MessageBox(PMBTYPE_WARNING, NULL, (const WCHAR *)get_string(STR_ID_PLX_BROW_ERR_INVALIDURL), UI_POPUP_NOTIFYDURATION_TIME);
//		 	PWBCBUINotifyProc((unsigned int)UM_ERROR, (unsigned long) ERR_INVALIDURL,0);
		}	
	}
#endif //__PLXBROW_SWITCH_PROTOCOL_
	else
	{
		//normal enter browser 
		return;
	}
	
}


#if 0
/****************************************************************************
* Function	RskPressedDeInitPlxBrowser
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
static void RskPressedDeInitPlxBrowser(void)
{
	 TryDestroyPlxBrowMainMenu();
	if(NULL  != plxBrowInfo.hBrow) 
	{
		DeInitPlxBrowserEngine();
		DeInitPlxBrowserUI();
		DeInitPlxBrowserUIData();
		nExittingBrowserFlags = EXIT_FLAG_RSKPRESSED;
		EntryExittingBrowserScreen();
	}
	else 
		DisplayIdleScreen();

}


/****************************************************************************
* Function	KeyEndDeInitPlxBrowser
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
void KeyEndDeInitPlxBrowser(void)
{

	 TryDestroyPlxBrowMainMenu();
	if(NULL  != plxBrowInfo.hBrow) 
	{
		DeInitPlxBrowserEngine();
		DeInitPlxBrowserUI();
		DeInitPlxBrowserUIData();
		nExittingBrowserFlags = EXIT_FLAG_KEYEND;
		EntryExittingBrowserScreen();
	}
	else 
		DisplayIdleScreen();
	
}


/****************************************************************************
* Function	ExittingBrowserTimerHandler
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
void ExittingBrowserTimerHandler(void)
{
	U16 prevScrId;
	static  int   nCount = 0;
	static  int   nEngineState;

	nCount ++;
	if(UM_EXIT != nEngineState)
		nEngineState = PlxBrowGetEngineState();
	if(5 >= nCount)
	{
		pixtel_UI_cancel_timer(ExittingBrowserTimerHandler);
		pixtel_UI_start_timer(PLXBROW_EXITTING_TIMER_DELAY,ExittingBrowserTimerHandler);
		return;
	}
	if( UM_EXIT == nEngineState)
	{
		if(EXIT_FLAG_RSKPRESSED == nExittingBrowserFlags)
		{
			if(TRUE == IsScreenPresent(SCR_ID_PLX_BROW_MAIN))
			{
				GetPreviousScrnIdOf( SCR_ID_PLX_BROW_MAIN,&prevScrId);
				GoBackToHistory(prevScrId);
			}
			else 
			{
				GetPreviousScrnIdOf( SCR_ID_PLX_BROW_VIEW,&prevScrId);
				GoBackToHistory(prevScrId);
			}
		}
		else if(EXIT_FLAG_KEYEND == nExittingBrowserFlags)
		{
			DisplayIdleScreen();
		}
		
		nCount = 0;
		bInExittingStatus = FALSE;
		nExittingBrowserFlags = Exit_FLAG_INVALID;
		PlxBrowInitEngineState();
		pixtel_UI_cancel_timer(ExittingBrowserTimerHandler);
		return;
	}
}


/****************************************************************************
* Function	RefreshExittingBrowserScreen
* Purpose	
* Params	
* Return	
* Remarks	
\****************************************************************************/
void RefreshExittingBrowserScreen(U16 message_id)
{
	if(SCR_ID_PLX_BROW_EXITTING == GetExitScrnID())