znscore.c

基于BREW 2.0 开发的冒险类手机游戏

			IFILE_Release(pFile);

			if(dwLow || dwHigh)
			{
				WSPRINTF(aszText, sizeof(aszText), aszFormat, dwHigh, dwLow);
				ITEXTCTL_SetText(pZnScore->m_pText, aszText, -1);
				ITEXTCTL_SetCursorPos(pZnScore->m_pText, TC_CURSOREND);
			}
		}

		IFILEMGR_Release(pFileMgr);
	}

	ITEXTCTL_SetMaxSize(pZnScore->m_pText, 12);
	ITEXTCTL_SetInputMode(pZnScore->m_pText, AEE_TM_NUMBERS);
	ITEXTCTL_SetActive(pZnScore->m_pText, TRUE);

	IDISPLAY_ClearScreen(pZnScore->m_App.m_pIDisplay);
	ITEXTCTL_Redraw(pZnScore->m_pText);
	IDISPLAY_DrawText(pZnScore->m_App.m_pIDisplay, AEE_FONT_NORMAL, aszTemp2, -1, 2, 2 * pZnScore->m_nFontSize + 6, NULL, 0);
	
	return TRUE;
}

boolean ZnScore_HandleEventInputNum(PZNSCORE pZnScore, AEEEvent eCode, uint16 wParam, uint32 dwParam)
{
	AECHAR aszTemp[] = { // 按选择键发出
		0x6309, 0x9009, 0x62E9, 0x952E, 0x53D1, 0x51FA, 0, 0};

	if(pZnScore->m_pText)
	{
		if(ITEXTCTL_HandleEvent(pZnScore->m_pText, eCode, wParam, dwParam))
			return TRUE;
	}

	switch(eCode)
	{
	case EVT_KEY:
		{
			AECHAR aszTemp[32];
			double dbTemp;
			IFileMgr * pFileMgr;
			IFile * pFile;
			
			MEMSET(aszTemp, 0, sizeof(aszTemp));
			ITEXTCTL_GetText(pZnScore->m_pText, aszTemp, 32);
			
			switch(wParam)
			{
			case AVK_CLR:
				if(WSTRLEN(aszTemp) == 0)
					ZnScore_ChangeGui(pZnScore, GS_IFUPLOAD);
				break;
			case AVK_SELECT:
				dbTemp = WSTRTOFLOAT(aszTemp);

				if(FCMP_L(dbTemp, 10000000000))
				{
					pZnScore->m_ErrorType = ET_INPUT;
					ZnScore_ChangeGui(pZnScore, GS_ERROR);
					return TRUE;
				}
				pZnScore->m_dbPhoneNum = dbTemp;

				MEMSET(&pZnScore->m_NetData, 0, sizeof(NETDATA));
				pZnScore->m_NetData.dwBufLen = 0;
				pZnScore->m_NetData.dwGameID = pZnScore->m_dwGameID;
				pZnScore->m_NetData.dwNetDataType = NDT_UPLOAD;
				pZnScore->m_NetData.dwScore = pZnScore->m_dwScore;
				pZnScore->m_NetData.dwUpperPhoneNum = (DWORD)FDIV(dbTemp, 1000000);
				pZnScore->m_NetData.dwLowerPhoneNum = (DWORD)FSUB(dbTemp, FMUL(pZnScore->m_NetData.dwUpperPhoneNum, 1000000));

				// Write to file here...
				if(SUCCESS == ISHELL_CreateInstance(pZnScore->m_App.m_pIShell, AEECLSID_FILEMGR, (void **)&pFileMgr))
				{
					boolean bWriten = TRUE;
					pFile = IFILEMGR_OpenFile(pFileMgr, _CONFIG_FILE_, _OFM_READWRITE);
					if(!pFile)
						pFile = IFILEMGR_OpenFile(pFileMgr, _CONFIG_FILE_, _OFM_CREATE);

					if(pFile)
					{
						if(sizeof(DWORD) != IFILE_Write(pFile, &pZnScore->m_NetData.dwLowerPhoneNum, sizeof(DWORD)))
							bWriten = FALSE;
						if(bWriten && sizeof(DWORD) != IFILE_Write(pFile, &pZnScore->m_NetData.dwUpperPhoneNum, sizeof(DWORD)))
							bWriten = FALSE;

						IFILE_Release(pFile);
					}
					else
						bWriten = FALSE;

					IFILEMGR_Release(pFileMgr);

					if(!bWriten)
					{
						pZnScore->m_ErrorType = ET_NOSPACE;
						ZnScore_ChangeGui(pZnScore, GS_ERROR);
						break;
					}
				}

				ZnNet_ReleaseNet(&pZnScore->m_ZnNet);
				ZnNet_InitNet(&pZnScore->m_ZnNet, pZnScore->m_App);

				ITEXTCTL_SetActive(pZnScore->m_pText, FALSE);
				ZnNet_Connect(&pZnScore->m_ZnNet, _SCORE_SVR_ADDR_, _SCORE_SVR_PORT_, (PFNNOTIFY)ZnScore_OnConnect1, pZnScore);

				ZnScore_ChangeGui(pZnScore, GS_QUERY);
				break;
			}
		}
		return TRUE;
	case EVT_APP_SUSPEND:
		ZnNet_ReleaseNet(&pZnScore->m_ZnNet);
		return TRUE;
	case EVT_APP_RESUME:
		IDISPLAY_ClearScreen(pZnScore->m_App.m_pIDisplay);
		ITEXTCTL_Redraw(pZnScore->m_pText);
		IDISPLAY_DrawText(pZnScore->m_App.m_pIDisplay, AEE_FONT_NORMAL, aszTemp, -1, 2, 2 * pZnScore->m_nFontSize + 6, NULL, 0);
		return TRUE;
	}

	return FALSE;
}

void ZnScore_ReleaseInputNum(PZNSCORE pZnScore)
{
	if(pZnScore->m_pText)
	{
		ITEXTCTL_Release(pZnScore->m_pText);
		pZnScore->m_pText = NULL;
	}
}

boolean ZnScore_InitError(PZNSCORE pZnScore)
{
	AEERect Rect;
	AEEItemStyle sel, normal;
	AEEMenuColors col;
	AECHAR aszItemOK[] = { // 确定
		0x786E, 0x5B9A, 0, 0};

	if(SUCCESS != ISHELL_CreateInstance(pZnScore->m_App.m_pIShell, AEECLSID_STATIC, (void **)&pZnScore->m_pStatic))
		return FALSE;

	ISTATIC_SetProperties(pZnScore->m_pStatic, ST_NOSCROLL);

	SETAEERECT(&Rect, 0, 0, pZnScore->m_unScrWidth, pZnScore->m_unScrHeight - pZnScore->m_nFontSize - 6);
	ISTATIC_SetRect(pZnScore->m_pStatic, &Rect);

	switch(pZnScore->m_ErrorType)
	{
	case ET_NETERROR:
		{
			AECHAR aszTemp[] = { // 网络传输错误！请确保网络可用。
				0x7F51, 0x7EDC, 0x4F20, 0x8F93, 0x9519, 0x8BEF, 0xFF01, 0x8BF7, 0x786E, 0x4FDD, 0x7F51, 0x7EDC, 0x53EF, 0x7528, 0x3002, 0, 0};
			ISTATIC_SetText(pZnScore->m_pStatic, NULL, aszTemp, AEE_FONT_NORMAL, AEE_FONT_NORMAL);
		}
		break;
	case ET_NOSPACE:
		{
			AECHAR aszTemp[] = { // 剩余空间不足！无法保存手机号码。
				0x5269, 0x4F59, 0x7A7A, 0x95F4, 0x4E0D, 0x8DB3, 0xFF01, 0x65E0, 0x6CD5, 0x4FDD, 0x5B58, 0x624B, 0x673A, 0x53F7, 0x7801, 0x3002, 0, 0};
			ISTATIC_SetText(pZnScore->m_pStatic, NULL, aszTemp, AEE_FONT_NORMAL, AEE_FONT_NORMAL);
		}
		break;
	case ET_INPUT:
		{
			AECHAR aszTemp[] = { // 输入格式有误！请重新输入。
				0x8F93, 0x5165, 0x683C, 0x5F0F, 0x6709, 0x8BEF, 0xFF01, 0x8BF7, 0x91CD, 0x65B0, 0x8F93, 0x5165, 0x3002, 0, 0};
			ISTATIC_SetText(pZnScore->m_pStatic, NULL, aszTemp, AEE_FONT_NORMAL, AEE_FONT_NORMAL);
		}
		break;
	default:
		{
			AECHAR aszTemp[] = { // 未知错误！
				0x672A, 0x77E5, 0x9519, 0x8BEF, 0xFF01, 0, 0};
			ISTATIC_SetText(pZnScore->m_pStatic, NULL, aszTemp, AEE_FONT_NORMAL, AEE_FONT_NORMAL);
		}
		break;
		// Add other error type
	}

	if(SUCCESS != ISHELL_CreateInstance(pZnScore->m_App.m_pIShell, AEECLSID_SOFTKEYCTL, (void **)&pZnScore->m_pMenu))
		return FALSE;

	normal.ft = _MENU_FT_;
	normal.xOffset = 0;
	normal.yOffset = 2;
	normal.roImage = _MENU_RO_;
	
	sel.ft = _MENU_SELECT_FT_;
	sel.xOffset = 0;
	sel.yOffset = 0;
	sel.roImage = _MENU_SELECT_RO_;
	
	col.cSelText = _MENU_SELECT_TEXT_;
	col.wMask = _MENU_COLOR_MASK_;
	
	col.cBack = _MENU_BACKGROUND_;
	col.cSelBack = _MENU_SELECT_BACKGROUND_;
	
	IMENUCTL_SetStyle(pZnScore->m_pMenu, &normal, &sel);
	IMENUCTL_SetColors(pZnScore->m_pMenu, &col);

	IMENUCTL_AddItem(pZnScore->m_pMenu, NULL, 0, _MENU_ITEM_BASE_, aszItemOK, 0);

	SETAEERECT(&Rect, 0, pZnScore->m_unScrHeight - pZnScore->m_nFontSize - 6, pZnScore->m_unScrWidth, pZnScore->m_nFontSize + 6);
	IMENUCTL_SetRect(pZnScore->m_pMenu, &Rect);

	IMENUCTL_SetActive(pZnScore->m_pMenu, TRUE);
	ISTATIC_SetActive(pZnScore->m_pStatic, TRUE);

	IMENUCTL_Redraw(pZnScore->m_pMenu);
	ISTATIC_Redraw(pZnScore->m_pStatic);

	return TRUE;
}

boolean ZnScore_HandleEventError(PZNSCORE pZnScore, AEEEvent eCode, uint16 wParam, uint32 dwParam)
{
	if(pZnScore->m_pMenu && pZnScore->m_pStatic)
	{
		if(IMENUCTL_HandleEvent(pZnScore->m_pMenu, eCode, wParam, dwParam))
			return TRUE;
		if(ISTATIC_HandleEvent(pZnScore->m_pStatic, eCode, wParam, dwParam))
			return TRUE;
	}
	
	switch(eCode)
	{
	case EVT_KEY:
		switch(wParam)
		{
		case AVK_CLR:
			switch(pZnScore->m_ErrorType)
			{
			case ET_NOSPACE:
				ZnNet_ReleaseNet(&pZnScore->m_ZnNet);
				ZnNet_InitNet(&pZnScore->m_ZnNet, pZnScore->m_App);

				IMENUCTL_SetActive(pZnScore->m_pMenu, FALSE);
				ISTATIC_SetActive(pZnScore->m_pStatic, FALSE);
				ZnNet_Connect(&pZnScore->m_ZnNet, _SCORE_SVR_ADDR_, _SCORE_SVR_PORT_, (PFNNOTIFY)ZnScore_OnConnect1, pZnScore);

				ZnScore_ChangeGui(pZnScore, GS_QUERY);
				break;
			default:
				ZnScore_ChangeGui(pZnScore, pZnScore->m_LastGuiState);
				break;
			}
			return TRUE;
		}
		break;
	case EVT_COMMAND:
		switch(wParam)
		{
		case _MENU_ITEM_BASE_:			// OK
			switch(pZnScore->m_ErrorType)
			{
			case ET_NOSPACE:
				ZnNet_ReleaseNet(&pZnScore->m_ZnNet);
				ZnNet_InitNet(&pZnScore->m_ZnNet, pZnScore->m_App);

				IMENUCTL_SetActive(pZnScore->m_pMenu, FALSE);
				ISTATIC_SetActive(pZnScore->m_pStatic, FALSE);
				ZnNet_Connect(&pZnScore->m_ZnNet, _SCORE_SVR_ADDR_, _SCORE_SVR_PORT_, (PFNNOTIFY)ZnScore_OnConnect1, pZnScore);

				ZnScore_ChangeGui(pZnScore, GS_QUERY);
				break;
			default:
				ZnScore_ChangeGui(pZnScore, pZnScore->m_LastGuiState);
				break;
			}
			return TRUE;
		}
		break;
	case EVT_APP_SUSPEND:
		return TRUE;
	case EVT_APP_RESUME:
		IMENUCTL_Redraw(pZnScore->m_pMenu);
		ISTATIC_Redraw(pZnScore->m_pStatic);
		return TRUE;
	}
	
	return FALSE;
}

void ZnScore_ReleaseError(PZNSCORE pZnScore)
{
	if(pZnScore->m_pStatic)
	{
		ISTATIC_Release(pZnScore->m_pStatic);
		pZnScore->m_pStatic = NULL;
	}
	
	if(pZnScore->m_pMenu)
	{
		IMENUCTL_Release(pZnScore->m_pMenu);
		pZnScore->m_pMenu = NULL;
	}
}

void ZnScore_OnConnect1(PZNSCORE pZnScore)
{
	if(pZnScore->m_ZnNet.m_LastResult != ERR_SUCCESS)
	{
		pZnScore->m_ErrorType = ET_NETERROR;
		ZnScore_ChangeGui(pZnScore, GS_ERROR);
		return;
	}

	ZnNet_NetWrite(&pZnScore->m_ZnNet, &pZnScore->m_NetData, sizeof(NETDATA), (PFNNOTIFY)ZnScore_OnWrite1, pZnScore);
}

void ZnScore_OnWrite1(PZNSCORE pZnScore)
{
	if(pZnScore->m_ZnNet.m_LastResult != ERR_SUCCESS)
	{
		pZnScore->m_ErrorType = ET_NETERROR;
		ZnScore_ChangeGui(pZnScore, GS_ERROR);
		return;
	}

	ZnNet_NetRead(&pZnScore->m_ZnNet, &pZnScore->m_NetData, sizeof(NETDATA), (PFNNOTIFY)ZnScore_OnRead1, pZnScore);
}

void ZnScore_OnRead1(PZNSCORE pZnScore)
{
	if(pZnScore->m_ZnNet.m_LastResult != ERR_SUCCESS)
	{
		pZnScore->m_ErrorType = ET_NETERROR;
		ZnScore_ChangeGui(pZnScore, GS_ERROR);
		return;
	}

	ZnNet_ReleaseNet(&pZnScore->m_ZnNet);
	pZnScore->m_bUploaded = (boolean)pZnScore->m_NetData.dwExData[0];
	pZnScore->m_bUpdated = (boolean)pZnScore->m_NetData.dwExData[1];
	ZnScore_ChangeGui(pZnScore, GS_IFQUERY);
}

void ZnScore_OnConnect2(PZNSCORE pZnScore)
{
	if(pZnScore->m_ZnNet.m_LastResult != ERR_SUCCESS)
	{
		pZnScore->m_ErrorType = ET_NETERROR;
		ZnScore_ChangeGui(pZnScore, GS_ERROR);
		return;
	}

	ZnNet_NetWrite(&pZnScore->m_ZnNet, &pZnScore->m_NetData, sizeof(NETDATA), (PFNNOTIFY)ZnScore_OnWrite2, pZnScore);
}

void ZnScore_OnWrite2(PZNSCORE pZnScore)
{
	if(pZnScore->m_ZnNet.m_LastResult != ERR_SUCCESS)
	{
		pZnScore->m_ErrorType = ET_NETERROR;
		ZnScore_ChangeGui(pZnScore, GS_ERROR);
		return;
	}

	ZnNet_NetRead(&pZnScore->m_ZnNet, &pZnScore->m_NetData, sizeof(NETDATA), (PFNNOTIFY)ZnScore_OnRead2, pZnScore);
}

void ZnScore_OnRead2(PZNSCORE pZnScore)
{
	if(pZnScore->m_ZnNet.m_LastResult != ERR_SUCCESS)
	{
		pZnScore->m_ErrorType = ET_NETERROR;
		ZnScore_ChangeGui(pZnScore, GS_ERROR);
		return;
	}

	// Allocated outside the normal initialization
	// Check if released when exit