keymap.cpp

MTK手机平台的MMI部分的源代码

	GetObject(img, sizeof(BITMAP), &bmp);
	DownArrow[2] = DownArrow[0] + bmp.bmWidth - 1;
	DownArrow[3] = DownArrow[1] + bmp.bmHeight - 1;

	/* left arrow key */
	GetPrivateProfileString("Coordinate", "KEY_LEFT_ARROW_LEFT", NULL, buffer, buffer_size, path);
	LeftArrow[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_LEFT_ARROW_TOP", NULL, buffer, buffer_size, path);
	LeftArrow[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_LEFT_ARROW", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_LEFT_ARROW] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_LEFT_ARROW]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_LEFT_ARROW] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_LEFT_ARROW], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	LeftArrow[2] = LeftArrow[0] + bmp.bmWidth - 1;
	LeftArrow[3] = LeftArrow[1] + bmp.bmHeight - 1;

	/* righy arrow key */
	GetPrivateProfileString("Coordinate", "KEY_RIGHT_ARROW_LEFT", NULL, buffer, buffer_size, path);
	RightArrow[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_RIGHT_ARROW_TOP", NULL, buffer, buffer_size, path);
	RightArrow[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_RIGHT_ARROW", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_RIGHT_ARROW] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_RIGHT_ARROW]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_RIGHT_ARROW] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_RIGHT_ARROW], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	RightArrow[2] = RightArrow[0] + bmp.bmWidth - 1;
	RightArrow[3] = RightArrow[1] + bmp.bmHeight - 1;

	/* SEND key */
	GetPrivateProfileString("Coordinate", "KEY_SEND_LEFT", NULL, buffer, buffer_size, path);
	KeyCall[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_SEND_TOP", NULL, buffer, buffer_size, path);
	KeyCall[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_SEND", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_SEND] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_SEND]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_SEND] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_SEND], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyCall[2] = KeyCall[0] + bmp.bmWidth - 1;
	KeyCall[3] = KeyCall[1] + bmp.bmHeight - 1;

	/* END key */
	GetPrivateProfileString("Coordinate", "KEY_END_LEFT", NULL, buffer, buffer_size, path);
	KeyEnd[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_END_TOP", NULL, buffer, buffer_size, path);
	KeyEnd[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_END", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_END] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_END]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_END] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_END], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyEnd[2] = KeyEnd[0] + bmp.bmWidth - 1;
	KeyEnd[3] = KeyEnd[1] + bmp.bmHeight - 1;

	/* STAR key */
	GetPrivateProfileString("Coordinate", "KEY_STAR_LEFT", NULL, buffer, buffer_size, path);
	KeyStar[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_STAR_TOP", NULL, buffer, buffer_size, path);
	KeyStar[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_STAR", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_STAR] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_STAR]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_STAR] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_STAR], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyStar[2] = KeyStar[0] + bmp.bmWidth - 1;
	KeyStar[3] = KeyStar[1] + bmp.bmHeight - 1;

	/* POUND key */
	GetPrivateProfileString("Coordinate", "KEY_POUND_LEFT", NULL, buffer, buffer_size, path);
	KeyHash[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_POUND_TOP", NULL, buffer, buffer_size, path);
	KeyHash[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_POUND", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_POUND] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_POUND]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_POUND] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_POUND], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyHash[2] = KeyHash[0] + bmp.bmWidth - 1;
	KeyHash[3] = KeyHash[1] + bmp.bmHeight - 1;

	/* volume-up key */
	GetPrivateProfileString("Coordinate", "KEY_VOL_UP_LEFT", NULL, buffer, buffer_size, path);
	VolumeUp[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_VOL_UP_TOP", NULL, buffer, buffer_size, path);
	VolumeUp[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_VOL_UP", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_VOL_UP] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_VOL_UP]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_VOL_UP] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_VOL_UP], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	VolumeUp[2] = VolumeUp[0] + bmp.bmWidth - 1;
	VolumeUp[3] = VolumeUp[1] + bmp.bmHeight - 1;

	/* volume-down key */
	GetPrivateProfileString("Coordinate", "KEY_VOL_DOWN_LEFT", NULL, buffer, buffer_size, path);
	VolumeDown[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_VOL_DOWN_TOP", NULL, buffer, buffer_size, path);
	VolumeDown[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_VOL_DOWN", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_VOL_DOWN] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_VOL_DOWN]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_VOL_DOWN] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_VOL_DOWN], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	VolumeDown[2] = VolumeDown[0] + bmp.bmWidth - 1;
	VolumeDown[3] = VolumeDown[1] + bmp.bmHeight - 1;

	/* KEY_CLEAR */
	GetPrivateProfileString("Coordinate", "KEY_CLEAR_LEFT", NULL, buffer, buffer_size, path);
	KeyClear[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_CLEAR_TOP", NULL, buffer, buffer_size, path);
	KeyClear[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_CLEAR", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_CLEAR] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_CLEAR]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_CLEAR] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_CLEAR], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyClear[2] = KeyClear[0] + bmp.bmWidth - 1;
	KeyClear[3] = KeyClear[1] + bmp.bmHeight - 1;

	/* KEY_QUICK_ACS */
	GetPrivateProfileString("Coordinate", "KEY_QUICK_ACS_LEFT", NULL, buffer, buffer_size, path);
	KeyMenu[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_QUICK_ACS_TOP", NULL, buffer, buffer_size, path);
	KeyMenu[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_QUICK_ACS", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_QUICK_ACS] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_QUICK_ACS]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_QUICK_ACS] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_QUICK_ACS], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyMenu[2] = KeyMenu[0] + bmp.bmWidth - 1;
	KeyMenu[3] = KeyMenu[1] + bmp.bmHeight - 1;

	/* KEY_ENTER */
	GetPrivateProfileString("Coordinate", "KEY_ENTER_LEFT", NULL, buffer, buffer_size, path);
	KeyEnter[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_ENTER_TOP", NULL, buffer, buffer_size, path);
	KeyEnter[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_ENTER", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_ENTER] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_ENTER]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_ENTER] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_ENTER], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyEnter[2] = KeyEnter[0] + bmp.bmWidth - 1;
	KeyEnter[3] = KeyEnter[1] + bmp.bmHeight - 1;

	/* KEY_EXTRA_1 */
	GetPrivateProfileString("Coordinate", "KEY_EXTRA_1_LEFT", NULL, buffer, buffer_size, path);
	KeyReserved1[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_EXTRA_1_TOP", NULL, buffer, buffer_size, path);
	KeyReserved1[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_EXTRA_1", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_EXTRA_1] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_EXTRA_1]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_EXTRA_1] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_EXTRA_1], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyReserved1[2] = KeyReserved1[0] + bmp.bmWidth - 1;
	KeyReserved1[3] = KeyReserved1[1] + bmp.bmHeight - 1;

	/* KEY_EXTRA_2 */
	GetPrivateProfileString("Coordinate", "KEY_EXTRA_2_LEFT", NULL, buffer, buffer_size, path);
	KeyReserved2[0] = atoi(buffer);
	GetPrivateProfileString("Coordinate", "KEY_EXTRA_2_TOP", NULL, buffer, buffer_size, path);
	KeyReserved2[1] = atoi(buffer);

	GetPrivateProfileString("Image", "KEY_EXTRA_2", NULL, buffer, buffer_size, path);
	if (device.key_bitmap[KEY_EXTRA_2] != NULL)
	{
		DeleteDC(device.key_bitmap[KEY_EXTRA_2]);
	}
	img = (HBITMAP)LoadImage(0, buffer, IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR | LR_LOADFROMFILE);
	device.key_bitmap[KEY_EXTRA_2] = CreateCompatibleDC(hdc);
	SelectObject(device.key_bitmap[KEY_EXTRA_2], img);

	GetObject(img, sizeof(BITMAP), &bmp);
	KeyReserved2[2] = KeyReserved2[0] + bmp.bmWidth - 1;
	KeyReserved2[3] = KeyReserved2[1] + bmp.bmHeight - 1;

	FeedBackFeelingKeyInit(hWnd, NULL, NULL);
	FeedBackFeelingKeyAction(-1);
	SendMessage(hWnd, WM_MOVE, 0, 0);

	/* restore the original working directory */
	SetCurrentDirectory(old_path);
} /* end of ReadKeyProfile */

#if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)

#include "kal_non_specific_general_types.h"
#include "lcd_sw_rnd.h" /* LCD width/height */

extern "C" 
{
	void mmi_pen_simulator_button_down_hdlr(S16 x, S16 y);
	void mmi_pen_simulator_button_move_hdlr(S16 x, S16 y);
	void mmi_pen_simulator_button_up_hdlr(S16 x, S16 y);
}
extern "C" U32 g_simulator_skin_lcd_x;
extern "C" U32 g_simulator_skin_lcd_y;

static BOOL g_touch_screen_sim_button_pressed = MMI_FALSE;

static void TouchScreenSimGetPoint(S16 *x, S16 *y)
{
	POINT point;
	GetCursorPos(&point);
	ScreenToClient(hWnd, &point);

	*x = (S16) (point.x - SIMULATOR_SKIN_LCD_X);
	*y = (S16) (point.y - SIMULATOR_SKIN_LCD_Y);
}


BOOL TouchScreenSimButtonDown(void)
{ 
	S16 x, y;

	TouchScreenSimGetPoint(&x, &y);

	if (x >= 0 && x < LCD_WIDTH && y  >= 0 && y < LCD_HEIGHT)
	{
		g_touch_screen_sim_button_pressed = MMI_TRUE;
		mmi_pen_simulator_button_down_hdlr(x, y);
		SetCapture(hWnd);
		return MMI_TRUE;
	}
	else
	{
		return MMI_FALSE;
	}
}


BOOL TouchScreenSimButtonMove(void)
{
	S16 x, y;

	if (g_touch_screen_sim_button_pressed)
	{
		TouchScreenSimGetPoint(&x, &y);
		mmi_pen_simulator_button_move_hdlr(x, y);
		return MMI_TRUE;
	}
	else
	{
		return MMI_FALSE;
	}
}


BOOL TouchScreenSimButtonUp(void)
{
	S16 x, y;

	if (g_touch_screen_sim_button_pressed)
	{
		TouchScreenSimGetPoint(&x, &y);
		mmi_pen_simulator_button_up_hdlr(x, y);
		g_touch_screen_sim_button_pressed = MMI_FALSE;
		ReleaseCapture();
		return MMI_TRUE;
	}
	else
	{
		return MMI_FALSE;
	}
}


#endif /* __MMI_TOUCH_SCREEN__ || __MMI_HANDWRITING_PAD__ */

/* [001] */
#endif /* MMI_ON_WIN32 */
#endif /* _KEYMAP_CPP */