guicallback.c

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

			else{
				pImgObj = PlxAppMalloc(sizeof(WBIMGOBJ));
				if (0 == pImgObj) {
					return -3;
				}
				for (i = 0; i < sizeof(WBIMGOBJ); ++ i) {
					*((char *)pImgObj + i) = 0;
				}
				pImgObj->szHeader = 8;
				pImgObj->pBuffer = PlxAppMalloc(len + pImgObj->szHeader);
				if (0 == pImgObj->pBuffer) {
					PlxAppFree(pImgObj);
					return -4;
				}
				*(pImgObj->pBuffer) = GDI_IMAGE_TYPE_GIF;
				*(long *)(&pImgObj->pBuffer[2]) = len;
				PlxAppMemcpy(pImgObj->pBuffer + pImgObj->szHeader, pData, len);
			}
			drawW = width;
			drawH = height;
			pImgObj->handler = (gdi_handle)PlxShowGif((UI_image_type)pImgObj->pBuffer,len, (long)drawX, (long)drawY,(long)drawW, (long)drawH);
			*hImage = pImgObj;
		}
		else{
			if( 0 != *hImage){
				pImgObj = *hImage;
				PlxEndShowGif((HGIF)pImgObj->handler);
				if (NULL != pImgObj && NULL != pImgObj->pBuffer)
					PlxAppFree(pImgObj->pBuffer);
				if (NULL != pImgObj)
					PlxAppFree(pImgObj);
				*hImage = 0;
			}
		}
		break;

	case  WBIMG_PNG:
#if defined(GDI_USING_HW_PNG) || defined(GDI_USING_W32_PNG)		
        if (-1 == src_width && -1 == src_height && 0 == src_x && 0 == src_y)
		{
            gdi_image_png_get_dimension((U8*)pData,len, (S32*)&picW, (S32*)&picH);	//get the true width and height
        }
		else
		{
			picW = src_width;
			picH = src_height;
		}
		drawW = width;
		drawH = height;
		if(0 != picW && 0 != picH)
			PlxMakeImageSizeForMTK((long*)&drawX, (long*)&drawY, (long)picW, (long)picH, (long*)&drawW, (long*)&drawH);
        gdi_image_png_draw_resized((S32)drawX, (S32)drawY, (S32)drawW, (S32)drawH, (U8*)pData, len);
#endif 
		break;

	default:
		return -2;
	}
#ifdef __PLXBROW_DEBUG_
    PlxTrace("[L%d]  Exit DrawImage drawX=%d drawY=%d drawW=%d drawH=%d \n\n",  __LINE__,drawX,drawY,drawW,drawH);
#endif
//	UnitPaintRect(drawX, drawY, drawX + drawW, drawY + drawH, &plxBrowInfo.rcPaint);
	return 0;
}

/****************************************************************************
* Function	PWBCBEndImageDraw
* Purpose	end image drawing function
* Params	
* Return	
* Remarks	
\****************************************************************************/
int PWBCBEndImageDraw( void* hImage, int imgType, void* param){
	PWBIMGOBJ pImgObj;

//	if(WBIMG_GIF == imgType)
	{
		if (hImage != 0) {
			pImgObj = hImage;
			PlxEndShowGif((HGIF)pImgObj->handler);
			if (NULL != pImgObj && NULL != pImgObj->pBuffer)
				PlxAppFree(pImgObj->pBuffer);
			if (NULL != pImgObj)
				PlxAppFree(pImgObj);
			hImage = 0;
		}
	}
	return 0;
}

/****************************************************************************
* Function	PWBCBStartRing
* Purpose	now it's a null function
* Params	
* Return	
* Remarks	
\****************************************************************************/
int PWBCBStartRing(int soundType, int playmode, unsigned char *data, int datalen){
	switch(soundType) 
	{
	case WBAUDIO_WAV:
		PlayAudioWavStream((U8*)data, (U16)datalen, DEVICE_AUDIO_PLAY_INFINITE);
		apf.bPlayWav = TRUE;
		break;
	case WBAUDIO_MIDI:
		PlayAudioMidiStream((U8*)data, (U16)datalen, DEVICE_AUDIO_PLAY_INFINITE);
		apf.bPlayMIDI = TRUE;
		break;
	case WBAUDIO_RMF:
//		PlayAudioStream((U8*)data, (U16)datalen, DEVICE_AUDIO_PLAY_INFINITE);
//		apf.bPlayOther = TRUE;
		break;
	case WBAUDIO_MMF:
		break;
	case WBAUDIO_AMR:
		PlayAudioStream((U8*)data, (U16)datalen, MEDIA_AMR, DEVICE_AUDIO_PLAY_INFINITE);
		apf.bPlayOther = TRUE;
		break;
	default:
		return -1;	// not supported format
	}
	return 0;
}

/****************************************************************************
* Function	PWBCBStopRing
* Purpose	now it's a null function
* Params	
* Return	
* Remarks	
\****************************************************************************/
int PWBCBStopRing(void){
	if (apf.bPlayWav) 
	{
		StopAudioWavStream();
	}
	if (apf.bPlayMIDI) 
	{
		StopAudioMidiStream();
	}
	if (apf.bPlayOther) 
	{
		StopAudioStream();
	}
	apf.bPlayWav = apf.bPlayMIDI = apf.bPlayOther = FALSE;
	return 0;
}

/****************************************************************************
* Function	PWBCBEditText
* Purpose	call input method to edit texts
* Params	
* Return	
* Remarks	
\****************************************************************************/
//int PWBCBEditText(WB_EDITTYPE iEditType, char *pBuffer, int iMaxCharLen, int iBufferLen, char *InputFormat, ECHO_FINISHEDITTEXT pFinishEdit){
int PWBCBEditText(WB_EDITTYPE iEditType, const char *pCurText, int iMaxCharLen,int iTextLen, const char *InputFormat, ECHO_FINISHEDITTEXT pFinishEditProc)
{
	
	if(NULL == pFinishEditProc)
		return -1;
	bInWaitingEchoCB = TRUE;

	if(-1 != iMaxCharLen && 0 >= iMaxCharLen)
	{
		pFinishEditProc(plxBrowInfo.hBrow, NULL, FALSE);
		bInWaitingEchoCB = FALSE;
		return -1;
	}
	if(-1 == iMaxCharLen)
	{
		pwbEditText.bufSize = PWBCB_EDIT_TEXT_BUFFER_SIZE;
		pwbEditText.nCharMaxNum = PWBCB_EDIT_TEXT_BUFFER_SIZE /2 - 1;
	}
	else
	{
		if(iTextLen > iMaxCharLen)
			pwbEditText.bufSize = (iTextLen+ 1)  * 3;
		else		
			pwbEditText.bufSize = (iMaxCharLen + 1)  * 3;
		pwbEditText.nCharMaxNum = iMaxCharLen;
	}
	pwbEditText.utf8Size = (pwbEditText.nCharMaxNum  + 1 ) * 3;
	pwbEditText.pUtf8 = PlxAppMalloc(pwbEditText.utf8Size);
	if (NULL  == pwbEditText.pUtf8) 
	{
		pFinishEditProc(plxBrowInfo.hBrow, pwbEditText.pUtf8, FALSE);
		DestroyEditTextInfo();
		bInWaitingEchoCB = FALSE;
		return -1;
	}
	strcpy((char*)pwbEditText.pUtf8 ,(const char*)"");
	pwbEditText.pBuf = PlxAppMalloc(pwbEditText.bufSize);
	if (NULL  == pwbEditText.pBuf) 
	{
		pFinishEditProc(plxBrowInfo.hBrow, pwbEditText.pUtf8, FALSE);
		DestroyEditTextInfo();
		bInWaitingEchoCB = FALSE;
		return -1;
	}

	if(NULL != pCurText && 0 < iTextLen)
		PlxUTF82UCS2((char *)pwbEditText.pBuf, (char *)pCurText, iTextLen, pwbEditText.bufSize);
	else
		pfnUnicodeStrcpy((S8*)pwbEditText.pBuf,(const S8*)"");
	pwbEditText.pFinishProc = pFinishEditProc;
	pwbEditText.inputFormat = ParseInputFormat(InputFormat);
	if ( iEditType == EDT_PASSWORD )
		pwbEditText.inputFormat = INPUT_TYPE_ALPHANUMERIC_PASSWORD;
	
	EnterEditTextScreen();
	return 0;
}


/****************************************************************************
* Function	FillPolygon
* Purpose	fill a polygon
* Params	
* Return	
* Remarks	
\****************************************************************************/
static void FillPolygon(const WB_POINT *lpPoints, int nCount, unsigned long color){
 // 边结构数据类型
	typedef struct Edge{
		int ymax;  // 边的最大y坐标
		float x; // 与当前扫描线的交点x坐标
		float dx; // 边所在直线斜率的倒数
		struct Edge * pNext; // 指向下一条边
	}Edge, * LPEdge;

	typedef struct tag_Want_Free{
		LPEdge p;
		struct tag_Want_Free * pNext;
	}WANTFREE, *PWANTFREE;

#define EDGE_LEFT	plxBrowInfo.rcInScreen.left
#define EDGE_TOP	plxBrowInfo.rcInScreen.top
#define EDGE_RIGHT	plxBrowInfo.rcInScreen.right
#define EDGE_BOTTOM	plxBrowInfo.rcInScreen.bottom

#define TRUELEFT(x)	(x < EDGE_LEFT ? EDGE_LEFT : x)
#define TRUETOP(y)	(y < EDGE_TOP ? EDGE_TOP : y)
#define TRUERIGHT(x)	(x > EDGE_RIGHT ? EDGE_RIGHT : x)
#define TRUEBOTTOM(y)	(y > EDGE_BOTTOM ? EDGE_BOTTOM : y)
#define TRUEX(x)	(TRUERIGHT(TRUELEFT(x)))
#define TRUEY(y)	(TRUEBOTTOM(TRUETOP(y)))
	
	int i=0,j=0,k=0;
	int y0=0,y1=0;  // 扫描线的最大和最小y坐标
	LPEdge pAET=NULL; // 活化边表头指针
	LPEdge * pET=NULL;  // 边表头指针
	PWANTFREE pHead = 0, pMv = 0, pCur = 0;

	pAET=PlxAppMalloc(sizeof(Edge)); // 初始化表头指针，第一个元素不用
	pAET->pNext=NULL;
	
	// 获取y方向扫描线边界
	y0=y1=TRUEY(lpPoints[0].y);
	for(i=1;i<nCount;i++)
	{
		if(TRUEY(lpPoints[i].y)<y0)
			y0=TRUEY(lpPoints[i].y);
		else if((TRUEY(lpPoints[i].y)>y1))
			y1=TRUEY(lpPoints[i].y);
	}
	if(y0>=y1) return;
	
	// 初始化边表，第一个元素不用
	pET=PlxAppMalloc(sizeof(LPEdge) *(y1-y0+1));
	for(i=0;i<=y1-y0;i++)
	{
		pET[i]=PlxAppMalloc(sizeof(Edge));
		pET[i]->pNext=NULL;
	}
	
	for(i=0;i<nCount;i++)
	{
		j=(i+1)%nCount; // 组成边的下一点
		if(TRUEY(lpPoints[i].y) != TRUEY(lpPoints[j].y))// 如果该边不是水平的则加入边表
		{
			LPEdge peg;   // 指向该边的指针
			LPEdge ppeg;  // 指向边指针的指针
			
			// 构造边
			peg =PlxAppMalloc(sizeof(Edge));
			pMv = PlxAppMalloc(sizeof(WANTFREE));
			if (0 == pCur) {
				pCur = pMv;
				pHead = pMv;
			}
			else{
				pCur->pNext = pMv;
				pCur = pMv;
			}
			pCur->p = peg;
			pCur->pNext = 0;
			k=(TRUEY(lpPoints[i].y)>TRUEY(lpPoints[j].y))?i:j;
			peg->ymax=TRUEY(lpPoints[k].y); // 该边最大y坐标
			k=(k==j)?i:j;  
			peg->x=(float)TRUEX(lpPoints[k].x); // 该边与扫描线焦点x坐标
			if(TRUEY(lpPoints[i].y) != TRUEY(lpPoints[j].y)) 
				peg->dx=(float)(TRUEX(lpPoints[i].x)-TRUEX(lpPoints[j].x))/
				(TRUEY(lpPoints[i].y)-TRUEY(lpPoints[j].y));// 该边斜率的倒数
			peg->pNext=NULL;
			
			// 插入边
			ppeg=pET[TRUEY(lpPoints[k].y)-y0]; 
			while(ppeg->pNext)
				ppeg=ppeg->pNext;
			ppeg->pNext=peg;
		}// end if
	}// end for i
	
	// 扫描
	for(i=y0;i<=y1;i++)
	{
		LPEdge peg0=pET[i-y0]->pNext;
		LPEdge peg1=pET[i-y0];
		if(peg0)// 有新边加入
		{
			while(peg1->pNext)
				peg1=peg1->pNext;
			peg1->pNext=pAET->pNext;
			pAET->pNext=peg0;
		}
		
		// 按照x递增排序pAET
		peg0=pAET;
		while(peg0->pNext)
		{
			LPEdge pegmax=peg0;
			LPEdge peg1=peg0;
			LPEdge pegi=NULL;
			
			while(peg1->pNext)
			{
				if(peg1->pNext->x>pegmax->pNext->x)
					pegmax=peg1;
				peg1=peg1->pNext;
			}
			pegi=pegmax->pNext;
			pegmax->pNext=pegi->pNext;
			pegi->pNext=pAET->pNext;
			pAET->pNext=pegi;
			if(peg0 == pAET)
				peg0=pegi;
		}
		
		// 遍历活边表，画线
		peg0=pAET;
		while(peg0->pNext)
		{
			if(peg0->pNext->pNext)
			{
				gdi_draw_line((S32)peg0->pNext->x, i, (S32)peg0->pNext->pNext->x, i,
					(gdi_color)PLXBROW_GETCOLOR(color)/*GDI_RGB_TO_BUFFER_FORMAT(GETRVALUE(color), GETGVALUE(color), GETBVALUE(color))*/);
				peg0=peg0->pNext->pNext;
			}
			else
				break;
		}
		
		// 把ymax=i的节点从活边表删除并把每个节点的x值递增dx
		peg0=pAET;
		while(peg0->pNext)
		{
			if(peg0->pNext->ymax <= i+2)
			{
				peg1=peg0->pNext;
				peg0->pNext=peg0->pNext->pNext; //删除
//				PlxAppFree(peg1);
				continue;
			}
			peg0->pNext->x+=peg0->pNext->dx; //把每个节点的x值递增dx
			peg0=peg0->pNext;
		}
	}
	
	pMv = pHead;
	while (pMv) {
		pCur = pMv;
		pMv = pCur->pNext;
		PlxAppFree(pCur->p);
		PlxAppFree(pCur);
	}
	// 删除边表
	for(i=0;i<y1-y0;i++)
		if(pET[i])
		{
			PlxAppFree(pET[i]);
			pET[i] = 0;
		}
		if(pAET) {
			PlxAppFree(pAET);
			pAET = 0;
		}
		if(pET){
			PlxAppFree(pET); 
			pET = 0;
		}
}

/****************************************************************************
* Function	EnterEditTextScreen
* Purpose	enter editor screen to edit text
* Params	
* Return	
* Remarks	
\****************************************************************************/
void ShowCategory5Screen(U16 title,U16 title_icon,U16 left_softkey,U16 left_softkey_icon,U16 right_softkey,U16 right_softkey_icon,s16 input_type,U8* buffer,S32 buffer_size,U8* history_buffer);
void SetCategory5RightSoftkeyFunction (void (*f)(void),MMI_key_event_type k);
static void EnterEditTextScreen(void){
	U8* guiBuffer;       /* Buffer holding history data */
	
	EntryNewScreen(SCR_ID_PLX_BROW_EDITTEXT, NULL, EnterEditTextScreen, NULL);
	guiBuffer = GetCurrGuiBuffer(SCR_ID_PLX_BROW_EDITTEXT);	
	ShowCategory5Screen(STR_GLOBAL_EDIT, IMG_ID_PLX_BROW,
		STR_GLOBAL_OPTIONS, IMG_GLOBAL_OPTIONS,
		STR_GLOBAL_BACK, IMG_GLOBAL_BACK,
			    pwbEditText.inputFormat, (U8*)pwbEditText.pBuf, pwbEditText.nCharMaxNum + 1,guiBuffer);

	SetCategory5RightSoftkeyFunction(EditTextCancel, KEY_EVENT_UP);
	SetLeftSoftkeyFunction(EnterEditTextOK, KEY_EVENT_UP);
	GuiCallbackKeyEndhanderFunc();
}


/*******************************************