//------------------------------------------------------------------------------

  // 파 일 명 : ix.c
  // 프로젝트 : fwp
  // 설    명 :
  // 작 성 자 : 유영창, 이영민, 문경원 , 이원재
  // 작 성 일 : 2009년 1월 17일
  // 수 정 일 :
  // 수 정 일 :
  // 주    의 :
  // 라이센스 : BSD

  // to do list :
  //  1. ix_scan_device()  : sprintf(filename_buf,"/sys/class/input/input%d/name",ix_mng[lp].input_number );

  //     과연 이정보가 필요한가 ? 만약 이 정보가 없다면 error로 retrun 해야 하는가?
  //	   내가 가지고 있는 보드에는 /sys/class/input/input0 정보가 없다. 그래도 event0가
  //	   있기 때문에 입력 값을 얻어오는 데는 문제 없다.

  //  3. press버튼은 버튼이 down되는 순간 값을 보내고 , ascii-2로 변환한다.
  //  4. 부가 기능 키 shitf, alt,...등의 키카 눌려 질 때는 code값을 전달하면 안된다. press에서 예를 들어 오른쪽 shtf키는 키값 6과 동일한 코드를 가진다.
  //     따라서 부가 기능 키가 눌려지면, key 값은0으로 해서 전달하자.

  //------------------------------------------------------------------------------
  #include <stdio.h>
  #include <string.h>
  
  #include <sys/poll.h>
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <string.h>
  
  #include <linux/input.h>
  #include <linux/limits.h>				// PATH_MAX

  #include <fcntl.h>                      // O_RDWR , O_NOCTTY 등의 상수 정의

  #include <time.h>
  
  #include <linux/kdev_t.h>				// MKDEV
  
  #include <sys/types.h>
  #include <sys/un.h>
  #include <termios.h>
  
  #include <pollmng.h>
  
  #include <sys/stat.h>
  
  #define _IX_VAR_ 1
  #include <ix.h>
  
  
  
  //--------------------------------------------------------------

  // 전역 변수

  //--------------------------------------------------------------

  #define ABS( x )   (((x) > 0 )? (x):-(x))		// 절대값

  static 	int				ix_error_code			= IXERR_NONE;				// 에러코드

  static	ix_mng_t		ix_mng[IX_INPUT_DEVICE_MAX];
  static	int				ix_mng_count			= 0;

  static	poll_obj_t 		*input_obj[IX_INPUT_DEVICE_MAX];					// 입력 디바이스에 대한 오브젝트

  
  
  static int				ix_sreen_x_min = 0;
  static int				ix_sreen_y_min = 0;
  
  static int				ix_sreen_x_max = IX_SCREEN_X_DEFAULT;
  static int				ix_sreen_y_max = IX_SCREEN_Y_DEFAULT;
  
  static int				ix_mouse_x = IX_SCREEN_X_DEFAULT/2;
  static int				ix_mouse_y = IX_SCREEN_Y_DEFAULT/2;

  static int				ix_key	    =0;											// KEY  입력값

  static ix_btn_state_t	ix_button_state =0;											// 버튼 상태값

  static unsigned long	ix_mouse_event_flag	 =0;									// 마우스 이벤트 발생 ( up ,down, move ..etc)
  static unsigned long	ix_key_event_flag	 =0;									// key    이벤트 발생 ( up ,down ,press )

  static unsigned long	ix_mouse_double_click_flag=0;

  static ix_event_func_t  ix_event_func = NULL;			// 함수 포인터 										//

  
  static ix_cal_touch_info_t  	ix_cal_touch_info[IX_CAL_TOUCH_INFO_MAX];
  static ix_adjust_touch_info_t  	ix_adjust_touch_info;

  static char 			ix_capslock_flag 	=0;										// 키보드 caps lock 플래그
  static char 			ix_numlock_flag 	=0;										// 키보드 caps numlock 플래그

  int  			ix_mouse_click_interval = IX_MOUSE_DOUBLE_CLICK_TIME_INTAVAL;		// 마우스 더블 클릭 타임 인터벌

  
  static struct timeval	ix_pre_time;
  
  static char ix_adjust_flag =0;
  static char ix_adjust_touch_flag =0;
  
  static char ix_askii[128] = {
  	KEY_RESERVED,
  
  	KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED,
  	KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED,
  
  	KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED,
  	KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED,
  
  	KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED,
  	KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED,
  
  	KEY_RESERVED ,KEY_SPACE ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED,
  	KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED,
  
  
  	KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_RESERVED ,KEY_MINUS,
  	KEY_DOT      ,KEY_SLASH    ,KEY_0		 ,KEY_1		   ,KEY_2	,
  	KEY_3,	KEY_4,	KEY_5,	KEY_6, KEY_7,
  
  	KEY_8,	KEY_9,	KEY_RESERVED ,KEY_SEMICOLON , KEY_RESERVED,
  	KEY_EQUAL, KEY_RESERVED, KEY_RESERVED,	KEY_RESERVED,
  
  	KEY_A ,KEY_B, KEY_C, KEY_D ,KEY_E,
  	KEY_F, KEY_G, KEY_H, KEY_I, KEY_J,
  	KEY_K, KEY_L, KEY_M, KEY_N ,KEY_O,
  	KEY_P, KEY_Q, KEY_R, KEY_S ,KEY_T,
  	KEY_U, KEY_V, KEY_W, KEY_X ,KEY_Y,
  	KEY_Z,
  
  	KEY_LEFTBRACE, KEY_RESERVED, KEY_RIGHTBRACE ,KEY_RESERVED ,KEY_RESERVED, KEY_RESERVED ,
  	KEY_A, KEY_B, KEY_C, KEY_D ,KEY_E,
  	KEY_F, KEY_G, KEY_H, KEY_I, KEY_J,
  	KEY_K, KEY_L, KEY_M, KEY_N ,KEY_O,
  	KEY_P, KEY_Q, KEY_R, KEY_S ,KEY_T,
  	KEY_U, KEY_V, KEY_W, KEY_X ,KEY_Y,
  	KEY_Z,
  	KEY_RESERVED, KEY_RESERVED, KEY_RESERVED ,KEY_RESERVED
  };
  
  //--------------------------------------------------------------

  // 함수

  //--------------------------------------------------------------
  static int ix_get_key_press_value(int *m_key, ix_btn_state_t button_state);
  
  
  //--------------------------------------------------------------

  // 설명 :
  // 매계 :
  // 반환 : 성공0, 실패-1

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------
  /** @brief

      @param  없음
      @return 0: 성공 , -1 실패
      @remark 없음

  *///----------------------------------------------------------------------------
  int ix_init( void )
  {

  	// 전역 변수 초기화 ... 나중에 하자.

  	ix_event_func = NULL;
  
  	memset(ix_cal_touch_info, 0, sizeof(ix_cal_touch_info_t)*IX_CAL_TOUCH_INFO_MAX);
  	memset(&ix_adjust_touch_info, 0, sizeof(ix_adjust_touch_info_t));
  
  	gettimeofday( &ix_pre_time, NULL );
  
  	return 0;
  }
  
  //------------------------------------------------------------------------------

  /** @brief     에러 메시지 문자열을 반환한다.
      @param     없음
      @return    에러 메시지 문자열을 반환한다.
      @remark		없음

  *///----------------------------------------------------------------------------
  static char  *ix_error_string( void )
  {

  	char *error_string[] ={ "에러 없음",                                    			//IXERR_NONE
  							"ix_read_event_data_low 함수 read 에러 ",               	//IXERR_READ
  							"ix_read_event_data_low 함수 fd 에러 ",						//IXERR_FD
  							"ix_scan_device 함수 장치 정보파일 오픈 에러",				//IXERR_DEV_INFO_OPEN
  							"ix_auto_scan_open 함수 에서 ix_scan_device 에러",			//IXERR_AUTOSCAN_SCANDEVICE
  							"ix_auto_scan_open 함수 에서 mknod 에러",					//IXERR_AUTOSCAN_MKNOD
  							"ix_auto_scan_open 함수 에서 디바이스 파일 오픈",			//IXERR_AUTOSCAN_DEVICE_OPEN
  							"ix_auto_scan_open 함수 에서 ex 함수 등록 에러",			//IXERR_AUTOSCAN_EX_ADD
  							"ix_write_event_low 함수 에서 잘못된 인자 에러",			//IXERR_WRITE_EVENT
  							"ix_write_mouse_button_action 함수 에서 잘못된 인자 에러",	//IXERR_WRITE_MOUSE_BUTTON_EVENT
  							"ix_write_keyboard_key_action 함수 에서 잘못된 인자 에러",	//IXERR_WRITE_KEYBOARD_EVENT

  
                          };
  	return( error_string[ix_error_code]);
  
  	//printf( "\r[gx error:%d]%s %s
  ", ex_error_code, ex_error_string(), msg);
  }
  
  //------------------------------------------------------------------------------

  /** @brief  ixlib에 에러코드, 에러문자열 및 사용자 메세지 출력
      @param  msg 사용자 메세지

      @return
      @remark
  *///----------------------------------------------------------------------------
  void ix_print_error( char *msg )
  {
  	printf( "\r[ix error:%d]%s %s
  ", ix_error_code, ix_error_string(), msg);
  	//return gx_error_code;
  }
  
  
  //------------------------------------------------------------------------------

  /** @brief  입력장치(키보드, 마우스..등등)에서 이벤트 데이터를 읽어 온다. 장치에 구별없이 동일한 데이터가 읽힌다.)
      @param	fd 			데이터를 읽어파일의 디스크립터
      @param	event_data	이벤트 데이터를 반환한다.
      @return	정상 :0, 실패 : -1
      @remark 이 함수를 이용하여 우선 입력 이벤트를 읽어온 후 장치별로 데이터를 분리해서 사용한다.

  *///----------------------------------------------------------------------------
  int ix_read_event_data_low(int fd, ix_event_t *event_data )
  {
  	int	read_size = 0;
  
  	if(fd <0)
  	{

  		ix_error_code = IXERR_FD; 		// 에러

  		return -1;
  	}
  
  	read_size = read( fd, event_data, sizeof(ix_event_t));
  
  	if(read_size != sizeof(ix_event_t))
  	{

  		ix_error_code = IXERR_READ; 	// 읽어온 데이터가 올바르지 않으면 에러다.

  		return -1;
  	}
  
  	return 0;
  
  }
  
  //------------------------------------------------------------------------------

  /** @brief 	디버깅용 함수이며, ix_event_t 데이터를 표시한다.
      @param	event_data  입력 장치에서 읽어온 이벤트 데이터

      @remark
  *///----------------------------------------------------------------------------
  void ix_debug_disp_event_data( ix_event_t *event_data )
  {
  
  	char *ix_code_rel_str[] = {
  								"REL_X        ",
  								"REL_Y        ",
  								"REL_Z        ",
  								"REL_RX       ",
  								"REL_RY       ",
  								"REL_RZ       ",
  								"REL_HWHEEL   ",
  								"REL_DIAL     ",
  								"REL_WHEEL    ",
  								"REL_MISC     ",
  							};
  
  	char *ix_code_abs_str[] = {
  								"ABS_X         ",
  								"ABS_Y         ",
  								"ABS_Z         ",
  								"ABS_RX        ",
  								"ABS_RY        ",
  								"ABS_RZ        ",
  								"ABS_THROTTLE  ",
  								"ABS_RUDDER    ",
  								"ABS_WHEEL     ",
  								"ABS_GAS       ",
  								"ABS_BRAKE     ",
  								"ABS_HAT0X     ",
  								"ABS_HAT0Y     ",
  								"ABS_HAT1X     ",
  								"ABS_HAT1Y     ",
  								"ABS_HAT2X     ",
  								"ABS_HAT2Y     ",
  								"ABS_HAT3X     ",
  								"ABS_HAT3Y     ",
  								"ABS_PRESSURE  ",
  								"ABS_DISTANCE  ",
  								"ABS_TILT_X    ",
  								"ABS_TILT_Y    ",
  								"ABS_TOOL_WIDTH",
  							};
  
  	//printf("[Sec]%ld, [uSec]%ld ",event_data->time.tv_sec, event_data->time.tv_usec );
  
  	switch(event_data->type)
  	{
      case    EV_SYN :  	printf("EV_SYN  ");		break;
  	case    EV_KEY :  	printf("EV_KEY  ");		break;

  	case    EV_ABS :    printf("EV_ABS  ");		break;      // 터치 스크린 입력

  	case    EV_REL :    printf("EV_ABS  ");		break;
  
      default : 	printf("[type]:%02x! " ,event_data->type); 			break;
  	}
  
  	switch(event_data->type)
  	{

   	case    EV_ABS :    // 절대값

   		printf("[code:%d]%s , [value]:%d  ",
   					event_data->code ,
   					ix_code_abs_str[event_data->code],
   					event_data->value
   			   );
   		break;

  	case    EV_REL :   	// 상대값

   		printf("[code:%d]%s , [value]:%d  ",
   					event_data->code ,
   					ix_code_rel_str[event_data->code],
   					event_data->value
   			   );
  		break;
  
      default : 	printf("[code]:%d ,[value]:%d " ,event_data->code ,event_data->value );
     		break;
  	}
  //	//printf("
  ");
  }
  
  
  
  //------------------------------------------------------------------------------

  /** @brief   키보드 값을 읽어 온다.
      @param   fd	키보드에 해당하는 파일디스크립터
      @param   key 현재 눌린 키값을 반환한다.
      @param   key_state 보조key의 값을 반환한다.

      @return  -1
      @remark
  *///----------------------------------------------------------------------------
  int ix_read_keyboard_low(int fd , int *key, int *key_state )
  {
  	ix_event_t	 event_data;

  	*key 		= KEY_RESERVED ;				// 초기화
  	*key_state 	= 0;							// 초기화

  
  	while(1)
  	{
  		if(ix_read_event_data_low(fd , &event_data ))	return -1;
  
  		//ix_debug_disp_event_data(&event_data );
  
  		if(event_data.type == EV_KEY)
  		{
  			*key 		= event_data.code;
  			*key_state	= event_data.value;
  		}

  		if(event_data.type == EV_SYN)			break;			// syn가 오면 나간다.

  	}
  
  	return 0;
  }
  
  
  //--------------------------------------------------------------

  // 설명 : 키보드 값을 읽어 온다.
  //        키보드를 누른값
  //        키가 눌리면 데이터가 두번 온다.
  //[Sec]665, [uSec]902491 EV_KEY  [code]:2 ,[value]:1       //value가 1이면 down

  //[Sec]665, [uSec]902604 EV_SYN  [code]:0 ,[value]:0

  // 따라서  key 값 2를 syn 될때 보네기 위해

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------
  /** @brief
      @param
      @return
      @remark
  *///----------------------------------------------------------------------------
  int ix_read_key_press_low(int fd , int *key )
  {

  	int 	key_state =0;					// syn하기 이전값 보전

  	ix_event_t	 event_data;

  	*key 	= KEY_RESERVED ;				// 초기화

  
  	while(1)
  	{
  		if(ix_read_event_data_low(fd , &event_data ))	return -1;
  
  		if(event_data.type == EV_KEY)
  		{
  			*key 		= event_data.code;
  			key_state	= event_data.value;
  		}
  
  		if(	 (event_data.type	== EV_SYN			)

  		   &&(key_state			== IX_KEY_VAULE_DOWN))  break;			// 키가 눌린 후 syn가 오면 나간다.

  	}
  
  	return 0;
  }
  
  
  //--------------------------------------------------------------

  // 설명 : mouse 값을 읽어 온다.
  // 인자 :
  //		*x	: REL_X 값
  //		*y	: REL_Y 값
  //		*btn: code 값을 이용하여 마우스 버튼 위치를 넘겨준다.
  //			  버튼은 동시에 여러게 누릴 수 있음으로 비트 마스크 하여 동시에 버튼이 눌리는 상태를 전달한다.

  //

  //  [예시1. 마우스 오른쪽버튼을 누르고, 마우스를 움직일 경우]
  //	type = 	EV_KEY, code = BTN_LEFT,	value = 1    <- 마우스 왼쪽 버튼이 눌림
  //	type = 	EV_REL, code = REL_X,		value = -14  <- X 좌표값은 -14이다.
  //	type = 	EV_REL, code = REL_Y,		value = 99   <- Y 좌표값은 +99이다.
  //	type = 	EV_SYN, code = 0,			value = 1    <- 지금까지 데이터가 하나의 데이터이다.

  //

  //	버튼이 눌린 상태에서 , 마우스를 움직이는 값을 확인 하려면,

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------

  /** @brief		터치스크린의 좌표값이 전달된다.
      @param	fd	터치스크린에 해당하는 파일디스크립터
      @param	x	x좌표값을 저장할 포인터 변수
      @param	y	y좌표값을 저장할 포인터 변수
      @param	press	읽어온 데이터의 type가 EV_KEY이고, code가 BTN_TOUCH일때의 value값을 저장할 포인터 변수
      @return	0	성공
      @return	-1	실패
      @remark		매계변수를 통해 좌표값이 전달된다.

  *///----------------------------------------------------------------------------
  int ix_read_touch_low(int fd , int *x, int *y, int *press )
  {
  
  	ix_event_t	 event_data;
  
  	while(1)
  	{
  		if(ix_read_event_data_low(fd , &event_data ))	return -1;
  
  		//ix_debug_disp_event_data(&event_data );
  
  		if( (event_data.type	== EV_KEY)
  		   &&(event_data.code	== BTN_TOUCH))
  		{
  			*press = event_data.value;
  		}
  
  		if( event_data.type	== EV_ABS)
  		{
  			if(event_data.code == ABS_X)	*x = event_data.value;
  
  			if(event_data.code == ABS_Y)	*y = event_data.value;
  		}

  		if(event_data.type == EV_SYN)			break;			// syn가 오면 나간다.

  	}
  	return 0;
  }
  
  
  
  //------------------------------------------------------------------------------

  /** @brief	마우스 입력 값을 얻어 온다.
      @param	fd	마우스 입력장치 파일 디스크립터
      @param	x	마우스 상태 x좌표값(REL_X) 반환한다.
      @param	y	마우스 상태 y좌표값(REL_Y) 반환한다.
      @param	btn	마우스 버튼 눌림을 반환한다.(code)
                  버튼은 동시에 여러게 누릴 수 있음으로 비트 마스크 하여 동시에 버튼이 눌리는 상태를 전달한다.
  
      @return -1 	마우스 입력 값을 읽기 실패
      @return 0 	마우스 입력 값읽기 성공
      @remark  [예시1. 마우스 오른쪽버튼을 누르고, 마우스를 움직일 경우]
  			type = 	EV_KEY, code = BTN_LEFT,	value = 1    <- 마우스 왼쪽 버튼이 눌림
  			type = 	EV_REL, code = REL_X,		value = -14  <- X 좌표값은 -14이다.
  			type = 	EV_REL, code = REL_Y,		value = 99   <- Y 좌표값은 +99이다.
  			type = 	EV_SYN, code = 0,			value = 1    <- 지금까지 데이터가 하나의 데이터이다.

  
  *///----------------------------------------------------------------------------

  /** @brief	마우스 입력 값을 얻어 온다.
      @param	fd	마우스 입력장치 파일 디스크립터
      @param	x	마우스 상태 x좌표값(REL_X)을 반환할 포인터 변수
      @param	y	마우스 상태 y좌표값(REL_Y)을 반환할 포인터 변수
      @param	btn	마우스 버튼 눌림을 반환한다.(code)
                  버튼은 동시에 여러게 누릴 수 있음으로 비트 마스크 하여 동시에 버튼이 눌리는 상태를 전달한다.
  
      @return -1 	마우스 입력 값을 읽기 실패
      @return 0 	마우스 입력 값읽기 성공
      @remark  [예시1. 마우스 오른쪽버튼을 누르고, 마우스를 움직일 경우]
  			type = 	EV_KEY, code = BTN_LEFT,	value = 1    <- 마우스 왼쪽 버튼이 눌림
  			type = 	EV_REL, code = REL_X,		value = -14  <- X 좌표값은 -14이다.
  			type = 	EV_REL, code = REL_Y,		value = 99   <- Y 좌표값은 +99이다.
  			type = 	EV_SYN, code = 0,			value = 1    <- 지금까지 데이터가 하나의 데이터이다.

  
  *///----------------------------------------------------------------------------
  int ix_read_mouse_low(int fd , int *x, int *y, int *btn)
  {
  	ix_event_t	 event_data;
  
  	while(1)
  	{
  		if(ix_read_event_data_low(fd , &event_data ))	return -1;
  
  		ix_debug_disp_event_data(&event_data );
  
  		if( event_data.type	== EV_KEY)
  		{
  			switch(event_data.code)
  			{
  			case BTN_LEFT	:

  					if(event_data.value == 1)	*btn |= IX_MOUSE_BTN_LEFT;		// 마우스 왼쪽 버튼이 눌림
  					else						*btn &= ~IX_MOUSE_BTN_LEFT;		// 마우스 왼쪽 버튼이 눌림 해제

  				 break;
  
  			case BTN_RIGHT	:

  					if(event_data.value == 1)	*btn |= IX_MOUSE_BTN_RIGHT;		// 마우스 오른쪽 버튼이 눌림
  					else						*btn &= ~IX_MOUSE_BTN_RIGHT;	// 마우스 오른쪽 버튼이 눌림 해제

  				 break;
  
  			case BTN_MIDDLE :

  					if(event_data.value == 1)	*btn |= IX_MOUSE_BTN_MIDDLE;	// 마우스 가운데 버튼이 눌림
  					else						*btn &= ~IX_MOUSE_BTN_MIDDLE;	// 마우스 가운데 버튼이 눌림 해제

  				 break;
  			}
  		}
  
  		if( event_data.type	== EV_REL)
  		{

  			if(event_data.code == REL_X)	*x = event_data.value;				// x 값을 저장

  			if(event_data.code == REL_Y)	*y = event_data.value;				// y 값을 저장

  		}

  		if(event_data.type == EV_SYN)			break;			// syn가 오면 나간다.

  	}
  	return 0;
  }
  
  
  
  //------------------------------------------------------------------------------

  /** @brief	장치의 USB 버스에 연결된 장치를 검색한 후 저장한다.
      @return	-1	실패
      @return	0	성공
      @remark  cat /proc/bus/input/devices 에서 input에 대한 정보가 없어도
  	         event에 대한 정보는 있는 경우가 있다.
  	         이경우 S: Sysfs=/class/input/input 에서 디바이드 이름 정보를 얻어 올 수 없는데
  	         이 디바이스 정보는 /proc/bus/input/devices 에서 얻어 올 수 있기 때문에 수정하였다.
  	         input 에 대한 정보가 없다면  -1을 저장하게 수정하였다.

  *///----------------------------------------------------------------------------
  int ix_scan_device(void)
  {
  	FILE *fp;
  	char read_buf[1024];
  	char filename_buf[PATH_MAX];			// 4096
  
  	char *name_ptr = NULL;
  	char *tmp_ptr = NULL;
  
  	int tmp_num1=0;
  	int tmp_num2=0;
  
  	int lp=0;
  
  	char *find_str;
  
  	fp = fopen(FILE_NAME_INPUT_INFO_BASE, "r");
  	if(fp == NULL)
  	{
  		ix_error_code = IXERR_DEV_INFO_OPEN;
  		return -1;
  	}

  	ix_mng_count = 0;		// 초기화

  	memset(ix_mng , 0, sizeof(ix_mng_t)*IX_INPUT_DEVICE_MAX);  // 초기화

  
  
  	while(!feof(fp))
  	{
  		if(ix_mng_count >= IX_INPUT_DEVICE_MAX) 	break;
  
  		memset(read_buf, 0, sizeof(read_buf));

  		fgets(read_buf, sizeof(read_buf)-1, fp );	// 한 줄씩 읽어온다.

  		//printf("[line data]%s" ,read_buf );

  		if(read_buf[0] == 'S')						//	입력 디바이스 번호를 스캔한다.

  		{
  			sscanf(read_buf, "S: Sysfs=/class/input/input%d" ,&tmp_num1);
  			ix_mng[ix_mng_count].input_number = tmp_num1;
  		}

  		if(read_buf[0] == 'H')						//	이벤트  디바이스 번호를 스캔한다.

  		{

  			find_str = strstr(read_buf, "event");	// 문자열에 "event" 가 있은 곳을 검색하고 , 있다면 부분 포인터를 넘겨준다.

  			if(find_str !=NULL)
  			{
  				sscanf(find_str, "event%d" ,&tmp_num1 );
  				ix_mng[ix_mng_count].event_number = tmp_num1;
  				printf( "event_number = %d
  ", ix_mng[ix_mng_count].event_number );
  			}

  			else //imesu 2월 13일 추가

  			{
  				ix_mng[ix_mng_count].event_number = -1;
  			}
  		}

  		if(read_buf[0] == 'N')							// imesu 2월 13일 추가 , 아래 주석처리한 부분을 대체하는 부분

  		{
  			name_ptr = strchr(read_buf,'=');

  			name_ptr++;  								// = 은 필요 없어서 제외

  			tmp_ptr = strchr(read_buf,'
  ');
  			//printf(" %s 
  ",name_ptr);
  
  			strncpy(ix_mng[ix_mng_count].name , name_ptr , tmp_ptr - name_ptr);		//
  		}

  		if(	read_buf[0] ==0x0a)	ix_mng_count++;	          // 0x0a 는 LF 즉 '\r'

  	}
  	fclose(fp);
  	
  //	printf( "ix_mng_count = %d
  ", ix_mng_count );

  	// 입력 장치이 major , minor 번호를 얻는다.

  	for(lp = 0 ; lp < ix_mng_count ; lp++)
  	{
  		sprintf(filename_buf,"/sys/class/input/event%d/dev" ,ix_mng[lp].event_number );
  		
  //		printf( "event_number = %d
  ", ix_mng[lp].event_number );
  
  		fp = fopen(filename_buf, "r");
  		if(fp !=NULL)
  		{
  			fscanf(fp , "%d:%d" ,&tmp_num1 ,&tmp_num2 );

  			ix_mng[lp].dev_major = tmp_num1;				// major 번호 저장
  			ix_mng[lp].dev_minor = tmp_num2;				// minor 번호 저장

  			
  //			printf( "major = %d, minor = %d
  ", ix_mng[lp].dev_major, ix_mng[lp].dev_minor );
  			
  			fclose(fp);
  		}

  		// 터치 디바이스 인가를 확인한다.

  //		sprintf(filename_buf,"/sys/class/input/input%d/capabilities/abs" ,ix_mng[lp].input_number );
  		sprintf(filename_buf,"/sys/class/input/input%d/capabilities/abs" ,ix_mng[lp].event_number );
  
  		fp = fopen(filename_buf, "r");
  		if(fp !=NULL)
  		{
  			fscanf(fp , "%d" ,&tmp_num1  );
  
  			printf( "FILE %s [%d]
  ", filename_buf, tmp_num1 );

  			if( tmp_num1 >= 3 ) ix_mng[lp].is_touch = 1;			// 터치 디바이스 이다.
  			else                ix_mng[lp].is_touch = 0;			// 터치 디바이스 아니다.

  
  			fclose(fp);
  		}
  
  	}

  	// 디버그 메시지

  /*
  	for(lp = 0 ; lp < ix_mng_count ; lp++)
  	{
  		printf(" [device name ]:%s  
  " ,ix_mng[lp].name );
  		printf(" [input number]:%d  
  " ,ix_mng[lp].input_number );
  		printf(" [event number]:%d  
  " ,ix_mng[lp].event_number );
  		printf(" [event major ]:%d  
  " ,ix_mng[lp].dev_major );
  		printf(" [event minor ]:%d  
  " ,ix_mng[lp].dev_minor );
  	}
  */
  
  	return 0;
  }
  
  
  
  //------------------------------------------------------------------------------

  /** @brief	사용자 영역에 이벤트를 전송한다.

      @param

      @return	0 성공

      @remark
  *///----------------------------------------------------------------------------
  static int ix_copy_to_user()
  {
  	ie_event_t 		ie_data;							// input event data;
  	int 			mx, my;

  	int 			mkey;								// 키보드 입력값

  	ix_get_mouse_position(&mx , &my);					// 마우스 좌표값을 넘겨준다.

  	ix_get_key_value(&mkey);							// keyboard 입력 값을 넘겨준다.

  
  	if( ix_mouse_event_flag & IX_MOUSE_FLAG_BTN_DOWN )
  	{
  		//printf("mouse down
  ");
  		ix_mouse_event_flag 	&= ~IX_MOUSE_FLAG_BTN_DOWN;

  		ie_data.data.mouse.x 	= mx;							// x 좌표값
  		ie_data.data.mouse.y 	= my;							// y 좌표값

  
  //		printf("mx:%d, my:%d ",mx, my);

  		ie_data.data.mouse.state= ix_button_state;				// 상태값

  		ie_data.type 		 	= IE_MOUSE_DOWN;
  		if(ix_event_func != NULL)  ix_event_func(&ie_data);
  	}
  
  	if( ix_mouse_event_flag & IX_MOUSE_FLAG_MOVE )
  	{
  		//printf("mouse move
  ");
  		ix_mouse_event_flag 	&= ~IX_MOUSE_FLAG_MOVE;
  		ie_data.data.mouse.x	 = mx;
  		ie_data.data.mouse.y	 = my;

  		ie_data.data.mouse.state = ix_button_state;				// 상태값

  		ie_data.type 			 = IE_MOUSE_MOVE;
  		if(ix_event_func != NULL)  ix_event_func(&ie_data);
  	}
  
  	if( ix_mouse_event_flag & IX_MOUSE_FLAG_BTN_UP )
  	{
  		//printf("mouse up
  ");
  		ix_mouse_event_flag 	&= ~IX_MOUSE_FLAG_BTN_UP;
  		ie_data.data.mouse.x	 = mx;
  		ie_data.data.mouse.y	 = my;

  		ie_data.data.mouse.state = ix_button_state;				// 상태값

  		ie_data.type 			 = IE_MOUSE_UP;
  		if(ix_event_func != NULL)  ix_event_func(&ie_data);
  	}

  	if( ix_key_event_flag & IX_KEY_VAULE_DOWN )					// key 가 눌렸다.

  	{
  		//printf("IX_KEY_VAULE_DOWN  
  ");
  		ix_key_event_flag		&= 	~IX_KEY_VAULE_DOWN;
  		ie_data.data.key.key	 = 	mkey;
  		ie_data.type 			 = 	IE_KEY_DOWN;

  		ie_data.data.key.state	 =	ix_button_state;				// 상태값

  		if(ix_event_func != NULL)	ix_event_func(&ie_data);
  	}

  	if( ix_key_event_flag & IX_KEY_VAULE_UP )						// key 가 눌림이 해제 되었다.

  	{
  		//printf("IX_KEY_VAULE_UP  
  ");
  		ix_key_event_flag    	&= 	~IX_KEY_VAULE_UP;
  		ie_data.data.key.key	= 	mkey;
  		ie_data.type 			= 	IE_KEY_UP;

  		ie_data.data.key.state  = 	ix_button_state;				// 상태값

  		if(ix_event_func != NULL)	ix_event_func(&ie_data);
  	}

  	if( ix_key_event_flag & IX_KEY_VAULE_PRESS )					// key 값을 사용자가 직관적으로 알수 있는 아스키 값으로 변환

  	{
  		ix_get_key_press_value(&mkey, ix_button_state);
  
  //		printf("IX_KEY_VAULE_PRESS %d 
  ", mkey);
  		ix_key_event_flag   	&= 	~IX_KEY_VAULE_PRESS;
  		ie_data.data.key.key	= 	mkey;
  		ie_data.type 			= 	IE_KEY_PRESS;

  		ie_data.data.key.state  =	ix_button_state;				// 상태값

  		if(ix_event_func != NULL)	ix_event_func(&ie_data);
  	}
  	return 0;
  }
  
  //------------------------------------------------------------------------------

  /** @brief	마우스 더블 클릭 간격 설정한다.
      @param	msec 마우스 입력이 들어오는 시간 간격, 단위는  msec이다.

      @return
      @remark
  *///----------------------------------------------------------------------------
  int  ix_set_mouse_double_click_intaval(int msec)
  {
  	ix_mouse_click_interval = msec;
  
  	return ix_mouse_click_interval;
  }
  
  //------------------------------------------------------------------------------

  /** @brief	마우스 더블 클릭을 확인한다.
      @param	cur_time	현제 마우스가 눌린 시간
      @return	1    더블클릭 성공
      @return	0    더블클릭 실패

      @remark
  *///----------------------------------------------------------------------------
  static int  ix_check_mouse_double_click( struct timeval cur_time)
  {
  /*
  	int intaval=0;

  	// 시간 확인

  	intaval = (cur_time.tv_usec - ix_pre_time.tv_usec);
  
  	printf("cur :%ld, old :%ld, intaval :%d 
  ", cur_time.tv_usec,ix_pre_time.tv_usec, intaval );
  	if(intaval < ix_mouse_click_interval)

  	{	// 초기화

  		ix_mouse_double_click_flag++;
  		if(ix_mouse_double_click_flag ==2 )
  		{
  			printf(">>>>>>> Double 
  ");
  			ix_mouse_double_click_flag =0;
  			ix_pre_time  = cur_time;
  			return 1;
  		}
  	}
  	else
  	{
  		//ix_mouse_double_click_flag=1;
  		//ix_pre_time  = cur_time;
  		return 0;
  	}
  */
  	return 0;
  
  }
  
  
  //------------------------------------------------------------------------------

  /** @brief	ix_event_t 에서 키( 마우스 버튼, 키보드 ) 입력의 값을 구별해서 버튼 상태 플레그(ix_button_state)를 설정한다.
      @param	event_data	입력 이벤트 데이터
      @return	0 함수 동작 완료

      @remark
  *///----------------------------------------------------------------------------
  static int ix_input_event_type_key(ix_event_t event_data)
  {
  	//printf("[code] 0x%x
  ",event_data.code );
  	switch(event_data.code)
  	{

  	case BTN_TOUCH  :					// touh 입력은 마우스의 left와 동일한 입력이다.

  	case BTN_LEFT	:

  			if(event_data.value)	ix_button_state |= IX_MOUSE_BTN_LEFT;			// 마우스 왼쪽 버튼이 눌림
  			else					ix_button_state &= ~IX_MOUSE_BTN_LEFT;			// 마우스 왼쪽 버튼이 눌림 해제

  		 	break;
  
  	case BTN_RIGHT	:

  			if(event_data.value)	ix_button_state |= IX_MOUSE_BTN_RIGHT;			// 마우스 오른쪽 버튼이 눌림
  			else					ix_button_state &= ~IX_MOUSE_BTN_RIGHT;			// 마우스 오른쪽 버튼이 눌림 해제

  		 	break;
  
  	case BTN_MIDDLE :

  			if(event_data.value)	ix_button_state |= IX_MOUSE_BTN_MIDDLE;			// 마우스 가운데 버튼이 눌림
  			else					ix_button_state &= ~IX_MOUSE_BTN_MIDDLE;		// 마우스 가운데 버튼이 눌림 해제

  			break;
  
  	case KEY_LEFTSHIFT :

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_BTN_LEFT_SHIFT;		// 키보드 왼쪽 shitf 버튼이 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_BTN_LEFT_SHIFT;	// 키보드 왼쪽 shitf 버튼이 눌림 해제

  		 	break;
  
  	case KEY_RIGHTSHIFT   :

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_BTN_RIGHT_SHIFT;	// 키보드 오른쪽 shitf 버튼이 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_BTN_RIGHT_SHIFT;	// 키보드 오른쪽 shitf 버튼이 눌림 해제

  		 	break;
  
  	case KEY_LEFTALT    :

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_BTN_LEFT_ALT;		// 키보드 왼쪽쪽 ALT 버튼이 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_BTN_LEFT_ALT;		// 키보드 오른쪽 ALT 버튼이 눌림 해제

  		 	break;
  
  	case KEY_RIGHTALT    :

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_BTN_RIGHT_ALT;		// 키보드 오른쪽 ALT 버튼이 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_BTN_RIGHT_ALT;		// 키보드 오른쪽 ALT 버튼이 눌림 해제

  		 	break;
  
  	case KEY_LEFTCTRL     :

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_BTN_LEFT_CTRL;		// 키보드 왼쪽쪽 CTRL 버튼이 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_BTN_LEFT_CTRL;		// 키보드 오른쪽 CTRL 버튼이 눌림 해제

  			break;
  
  	case KEY_RIGHTCTRL     :

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_BTN_RIGHT_CTRL;		// 키보드 오른쪽 CTRL 버튼이 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_BTN_RIGHT_CTRL;	// 키보드 오른쪽 CTRL 버튼이 눌림 해제

  			break;
  
  	case KEY_CAPSLOCK     :	// imesu 090215

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_CAPSLOCK;		// 키보드 오른쪽 CTRL 버튼이 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_CAPSLOCK;		// 키보드 오른쪽 CTRL 버튼이 눌림 해제

  			break;
  
  
  	case KEY_NUMLOCK     :	// imesu 090215

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_NUMLOCK;			// 키보드 Num Lock 버튼이 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_NUMLOCK;		// 키보드 Num Lock 버튼이 눌림 해제

  			break;
  
  	case KEY_UP     :		// imesu 090215

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_UP;				// 키보드 윗쪽 방향키 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_UP;				// 키보드 윗쪽 방향키 눌림 해제

  			break;
  
  	case KEY_DOWN   :		// imesu 090215

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_DOWN;			// 키보드 아래쪽 방향키 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_DOWN;			// 키보드 아래쪽 방향키 눌림 해제

  			break;

  	case KEY_LEFT    :		// imesu 090215  방향키
  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_LEFT;			// 키보드 왼쪽 방향키 버튼 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_LEFT;			// 키보드 왼쪽 방향키 버튼 툴림 해제

  			break;
  
  	case KEY_RIGHT    :		// imesu 090215

  			if(event_data.value)	ix_button_state |= IX_KEYBOARD_RIGHT;			// 키보드 오른쪽 방향키 버튼 눌림
  			else					ix_button_state &= ~IX_KEYBOARD_RIGHT;			// 키보드 오른쪽 방향키 버튼 눌림 해제

  			break;

  	default : // 주의 : 버튼 말고 나머지는 키보드로 처리했다. 나중에 수정할 부분
  		  //if(event_data.value == 1)	ix_button_state= event_data.value;				// key가 눌려있을때 값을 무조건 넣는다.

  		  	break;
  	}

  	// 더블 클릭 확인

  	switch(event_data.code)
  	{

  	case BTN_TOUCH  :					// touh 입력은 마우스의 left와 동일한 입력이다.

  	case BTN_LEFT	:
  			if(ix_check_mouse_double_click(event_data.time))
  			{

  				if(event_data.value)	ix_mouse_event_flag |=IX_MOUSE_FLAG_DOUBLE_CLICK;	//마우스가 눌렸다.
  				else					ix_mouse_event_flag &=~IX_MOUSE_FLAG_DOUBLE_CLICK;		// 마우스가 눌림 해제

  			}
  			break;
  
  	default :
  
  			break;
  	}

  	// FLAG설정

  	switch(event_data.code)
  	{

  	case BTN_TOUCH  :					// touh 입력은 마우스의 left와 동일한 입력이다.

  	case BTN_LEFT	:
  	case BTN_RIGHT	:
  	case BTN_MIDDLE :

  			if(event_data.value)	ix_mouse_event_flag |=IX_MOUSE_FLAG_BTN_DOWN;	//마우스가 눌렸다.
  			else					ix_mouse_event_flag |=IX_MOUSE_FLAG_BTN_UP;		// 마우스가 눌림 해제

  			break;

  	case KEY_CAPSLOCK     :				// imesu 090215 버튼을 누르면 DOWN -> UP이 된다. 즉 2번ix_input_event_type_key()가 호출된다. 그래서 DOWN 될때 FLAG 설정하게 한다.

  			if(event_data.value)
  			{

  				ix_key_event_flag |= IX_KEY_VAULE_DOWN;								// 키보드 Num Lock 버튼이 눌림
  				ix_key_event_flag |= IX_KEY_VAULE_PRESS;							// key가 눌렸다. low code 값을 ascii값으로 변환 ex) KEY_1 -> 0x30

  				if(!ix_capslock_flag)		ix_capslock_flag = FLAG_SET;			// CapsLock 기능이 설정 되었다.
  				else 						ix_capslock_flag = FLAG_RELEASE;		// CapsLock 기능이 해제 되었다.

  			}
  			else
  			{
  				ix_key_event_flag |= IX_KEY_VAULE_UP;
  			}
  
  			break;
  
  
  	case KEY_NUMLOCK     :	// imesu 090215
  			if(event_data.value)
  			{

  				ix_key_event_flag 		|= IX_KEY_VAULE_DOWN;						// 키보드 Num Lock 버튼이 눌림
  				ix_key_event_flag 		|= IX_KEY_VAULE_PRESS;						// key가 눌렸다. low code 값을 ascii값으로 변환 ex) KEY_1 -> 0x30

  				if(!ix_numlock_flag) 	ix_numlock_flag = FLAG_SET;					// CapsLock 기능이 설정 되었다.
  				else 					ix_numlock_flag = FLAG_RELEASE;				// CapsLock 기능이 해제 되었다.

  			}
  			else
  			{
  				ix_key_event_flag |= IX_KEY_VAULE_UP;
  			}
  			break;

  	default : // 주의 : 버튼 말고 나머지는 키보드로 처리했다. 나중에 수정할 부분
  			ix_key = event_data.code;								// key 값을 넣는다.

  
  		  	if(event_data.value )
  		  	{

  		  		ix_key_event_flag |= IX_KEY_VAULE_DOWN;				// key가 눌렸다. low code 값을 전달
  		  		ix_key_event_flag |= IX_KEY_VAULE_PRESS;			// key가 눌렸다. low code 값을 ascii값으로 변환 ex) KEY_1 -> 0x30

  		  	}
  		  	else
  		  	{

  		  		ix_key_event_flag |= IX_KEY_VAULE_UP;				// key가 눌렸다.

  			}
  			break;
  	}
  	return 0;
  }
  
  
  
  
  //------------------------------------------------------------------------------

  /** @brief	ix_event_t 에서 입력 장치(마우스 )에서, REL 입력 값을 구별해서 ix_mouse_x, ix_mouse_y에 저장한다.
      @param	event_data	입력 이벤트 데이터
      @return	0 함수 동작 완료
      @brief	상대 좌표(REL_X, REL_Y) 입력값 전역변수 ix_mouse_x, ix_mouse_y에 저장한다.
      @param	event_data	입력 이벤트 데이터
      @return	0 함수 동작 완료

      @remark
  *///----------------------------------------------------------------------------
  static int ix_input_event_type_rel(ix_event_t event_data)
  {
  	if(event_data.code == REL_X)
  	{

  		ix_mouse_x += event_data.value;							// x 값을 저장

  
  		if(ix_mouse_x < ix_sreen_x_min )	ix_mouse_x = ix_sreen_x_min;
  		if(ix_mouse_x >= ix_sreen_x_max )	ix_mouse_x = ix_sreen_x_max-1;
  	}
  	if(event_data.code == REL_Y)
  	{

  		ix_mouse_y += event_data.value;							// y 값을 저장

  
  		if(ix_mouse_y < ix_sreen_y_min )	ix_mouse_y = ix_sreen_y_min;
  		if(ix_mouse_y >= ix_sreen_y_max )	ix_mouse_y = ix_sreen_y_max-1;
  	}
  
  	ix_mouse_event_flag |=IX_MOUSE_FLAG_MOVE;
  
  	return 0;
  }
  
  //--------------------------------------------------------------

  // 설명 : ABS 값 처리

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------

  /** @brief	ix_event_t 에서 입력 장치(마우스 )에서, ABS 입력 값을 구별해서 ix_mouse_x, ix_mouse_y에 저장한다.
      @param	event_data	입력 이벤트 데이터
      @return	0 함수 동작 완료
      @brief	절대 좌표(ABS_X, ABS_Y) 입력값을 전역변수 ix_mouse_x, ix_mouse_y에 저장한다.
      @param	event_data	입력 이벤트 데이터
      @return	0 함수 동작 완료

      @remark
  *///----------------------------------------------------------------------------
  static int ix_input_event_type_abs(ix_event_t event_data)
  {
  
  	int x, y;
  	if(event_data.code == ABS_X)
  	{

  		ix_mouse_x = event_data.value;							// x 값을 저장

  
  		if(ix_adjust_touch_flag)
  		{
  			x = (ix_adjust_touch_info.xa * ix_mouse_x + ix_adjust_touch_info.xb) / IX_CAL_TOUCH_INFO_OFSSET;
  
  			if(x <= 0)
  			{
  				x =0;
  			}
  			else if(x >= ix_sreen_x_max)
  			{
  				x = ix_sreen_x_max;
  			}
  
  			ix_mouse_x = x;
  		}
  
  	}
  	if(event_data.code == ABS_Y)
  	{

  		ix_mouse_y = event_data.value;							// y 값을 저장

  
  		if(ix_adjust_touch_flag)
  		{
  			y = (ix_adjust_touch_info.ya * ix_mouse_y + ix_adjust_touch_info.yb) / IX_CAL_TOUCH_INFO_OFSSET;
  
  			if(y <= 0)
  			{
  				y =0;
  			}
  			else if(y >= ix_sreen_y_max)
  			{
  				y = ix_sreen_y_max;
  			}
  
  			ix_mouse_y = y;
  		}
  	}
  
  
  
  	ix_mouse_event_flag |= IX_MOUSE_FLAG_MOVE;
  
  	//printf("mx:%d, my:%d ",ix_mouse_y, ix_mouse_y);
  
  }
  
  
  //------------------------------------------------------------------------------

  /** @brief	이벤트 입력을 읽어 온 후 IX EVENT 메시지를 들며, 이벤트 라이브러리(exLib)에 등록하기 위한 사전 작업을 한다.
      @param	on_self	이벤트 라이브러리(exLib)에 등록하기 위한 포인터 변수이다.
      @return	0	성공

      @remark
  *///----------------------------------------------------------------------------
  static int ix_event_read(void *on_self )
  {
  
  	poll_obj_t		*mng      = NULL;
  
  	ix_event_t 		event_data;
  
  	mng = (poll_obj_t *)on_self;
  
  	ix_read_event_data_low(mng->fd , &event_data);

  	//ix_debug_disp_event_data(&event_data);						// 이벤트 데이터 를 확인한다.

  
  	switch(event_data.type)
  	{
  	case EV_KEY :	ix_input_event_type_key(event_data);	break;
  
  	case EV_REL :	ix_input_event_type_rel(event_data);	break;
  
  	case EV_ABS :	ix_input_event_type_abs(event_data);	break;

  	case EV_SYN :	ix_copy_to_user();		break;				// 사용자 영역에 이벤트를 전송한다.

  
  	default : break;
  	}
  
  	return 0;
  
  }
  
  
  
  //------------------------------------------------------------------------------

  /** @brief	검색된 장치를 mknod 한후 ,파일을 Open한다. 
  
  			참고 : http://forum.falinux.com/zbxe/?mid=Kernel_API&document_srl=405682&listStyle=&cpage=
      @param	path	: 기본 위치
  	@param	major	: 장치의 major 번호
  	@param	minor	: 장치의 minor 번호
  	@param	open_flag : open 할때 flag 옵션
      @return	성공 : 파일 디스크립션 , 0보다 크거나 같다. 
  
  			실패 : 0 보다 작다.
      @remark	Thread 는 고려되어있지 않음

  
  *///----------------------------------------------------------------------------
  int ux_mknod_device_open(char *path, char major, char minor , int open_flag)
  {
  	char 	file_name[PATH_MAX];			// 4096
  	int		dev_fd =0;
  
  	static 	int mknod_count =0;

  	sprintf(file_name, "%s-%d-%d", path , getpid(), ++mknod_count ); // 중복 방지

  	remove(file_name);												// 당장 삭제 기존에 있는건 삭제한다. remove함수는 누가 open하고 있으면 실패

  	// mknod 한다.

  	mknod(file_name, (S_IRWXU|S_IRWXG|S_IFCHR), MKDEV(major , minor));

  	dev_fd = open(file_name, open_flag);							// mknod 된 파일을 open 한 후 fd를 얻어온다.

  	if(dev_fd < 0)		return dev_fd;

  	unlink(file_name);										   		// 프로세스가 종료될 때 자동의 파일 삭제 .. 지금 당장 삭제되는게 아니다.^^;

  
  	return dev_fd;
  }
  
  
  
  //------------------------------------------------------------------------------

  /** @brief	검색된 장치를 mknod 한다.
   			1)입력 장치를 자동 검색

   			2) mknod

   			3) 디바이스 파일 오픈..
   			4) ex 함수 등록    @param
  	@param	path	기본 디렉토리 위치
      @return	0	성공
      @return	1	실패

      @remark
  *///----------------------------------------------------------------------------
  int	ix_auto_scan_open( char *path )
  {
  	char 	device_path[PATH_MAX];							// 4096
  	int		lp=0;

  	// 1)입력 장치를 자동 검색

  	if(ix_scan_device() <0)
  	{
  		ix_error_code = IXERR_AUTOSCAN_SCANDEVICE;
  		return -1;
  	}
  
  	// 2) mknod

  	// 3) 디바이스 파일 오픈..

  	for( lp= 0 ; lp < ix_mng_count;lp++)
  	{
  		sprintf(device_path, "%s/event%d", path, ix_mng[lp].event_number);
  		ix_mng[lp].fd = ux_mknod_device_open(device_path ,ix_mng[lp].dev_major ,ix_mng[lp].dev_minor, O_RDWR );
  
  		if(ix_mng[lp].fd < 0)	continue;

  		// 4) ex 함수 등록

  		//poll_obj_t *poll_add( int fd )
  		input_obj[lp] 			= poll_add( ix_mng[lp].fd );
  
  		if(input_obj[lp] == NULL) continue;
  
  		input_obj[lp]->type = STYP_FILE;
  		input_obj[lp]->on_poll_in  = ix_event_read;			// read
  
  	}
  
  	poll_rebuild();
  
  	return 0;
  }
  
  //--------------------------------------------------------------

  // 설명 : 터치 파일 디스크립터를 얻는다.
  //        자동으로 mknod 한다.
  // 			1) 입력 장치중 터치 검색

  // 			2) mknod

  // 			3) 디바이스 파일 오픈..
  // 			4) ex 함수 등록
  // 매개 : path : 기본 디렉토리 위치
  // 반환 :	fd 	파일 디스크립터
  // 주의 :

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------

  /** @brief	터치 파일 디스크립터를 얻은 후 자동으로 mknod 한다.
   			1) 입력 장치중 터치 검색

   			2) mknod

   			3) 디바이스 파일 오픈..
   			4) ex 함수 등록
  	@param	path	기본 디렉토리 위치
      @return	fd 	파일 디스크립터
      @return	-1 	실패

      @remark
  *///----------------------------------------------------------------------------
  int ix_get_touch_fd( char *path )
  {
  	char 	device_path[PATH_MAX];							// 4096
  	int lp;
  
  	for( lp= 0 ; lp < ix_mng_count;lp++)
  	{
  		if( !ix_mng[lp].is_touch ) continue;
  
  //		printf( "INDEX %d
  " , lp );
  
  		sprintf(device_path, "%s/event%d", path, ix_mng[lp].event_number);
  		ix_mng[lp].fd = ux_mknod_device_open(device_path ,ix_mng[lp].dev_major ,ix_mng[lp].dev_minor, O_RDWR );
  
  		if(ix_mng[lp].fd >= 0 )	return ix_mng[lp].fd;
  	}
  
  	return -1;
  }
  
  //------------------------------------------------------------------------------

  /** @brief	스크린 사이즈를 설정하고, 마우스를 정중앙으로 위치하게 초기화한다.

      @param
      @return
      @remark
  *///----------------------------------------------------------------------------
  int ix_set_screen_size(int x, int y)
  {
  	ix_sreen_x_max = x;
  	ix_sreen_y_max = y;
  
  	ix_mouse_x	= (ix_sreen_x_max - ix_sreen_x_min )/2 + ix_sreen_x_min ;
  	ix_mouse_y	= (ix_sreen_y_max - ix_sreen_y_min )/2 + ix_sreen_y_min ;
  
  	return 0;
  }
  
  //------------------------------------------------------------------------------

  /** @brief	마우스 현재 좌표 얻어온다.
      @param	x	마우스 x좌표값을 얻는 포인터 변수
      @param	y	마우스 y좌표값을 얻는 포인터 변수
      @return	0 완료
      @remark	매개변수를 통해 좌표값을 반환한다.

  *///----------------------------------------------------------------------------
  
  
  
  int ix_get_mouse_position(int *x, int *y)
  {
  	*x = ix_mouse_x;
  	*y = ix_mouse_y;
  
  	return 0;
  }
  
  //------------------------------------------------------------------------------

  /** @brief	이벤트 데이터를 처리할 함수를 등록한다.
      @param	func	등록할 함수이름
      @return	0	성공

      @remark
  *///----------------------------------------------------------------------------
  int ix_add_event(ix_event_func_t func)
  {
  	ix_event_func = (ix_event_func_t) func;
  
  	return 0;
  }
  
  //------------------------------------------------------------------------------

  /** @brief	현재 key 값을 얻어 온다.
      @param	key	키값을 얻는 포인터 변수
      @return	0 완료
      @remark	매개변수를 통해 좌표값을 반환한다.

  *///----------------------------------------------------------------------------
  int ix_get_key_value(int *key)
  {
  	*key = ix_key;
  
  	return 0;
  }
  
  //------------------------------------------------------------------------------

  /** @brief	touch screen 값을 보정하기 위한 값을 넣는다.

      @param

      @return	-1	에러 발생
      @return	0	정상

      @remark
  *///----------------------------------------------------------------------------
  int ix_set_cal_touch_info(int index ,ix_cal_touch_info_t one_point)
  {
  
  	int tx =0;
  	int ty =0;
  
  	if(index < 0)						return -1;
  	//if(index >=IX_CAL_TOUCH_INFO_MAX) 	return -1;
  
  	ix_cal_touch_info[index] = one_point;
  
  //	printf("\r x[%d]:%d , y[%d]:%d ",index ,ix_cal_touch_info[index].sx ,index ,ix_cal_touch_info[index].sy);
  //	printf("\r x[%d]:%d , y[%d]:%d ",index ,ix_cal_touch_info[index].tx ,index ,ix_cal_touch_info[index].ty);
  //	printf("
  ");
  
  	ix_adjust_flag =0;
  	return 0;
  }
  
  
  //------------------------------------------------------------------------------

  /** @brief	touch screen 값을 보정을 위한 기준 값을 설정한다.
      @param	없음
      @return	0 성공

      @remark
  *///----------------------------------------------------------------------------
  int ix_adjust_touch( void )
  {
  	int tx1 =0; //touch min
  	int tx2 =0;	//touch max
  
  	int sx1 =0; //screen min
  	int sx2 =0;	//screen max
  
  	int ty1 =0; //touch min
  	int ty2 =0; //touch max
  
  	int sy1 =0; //screen min
  	int sy2 =0;	//screen max
  
  	tx1 =(ix_cal_touch_info[0].tx + ix_cal_touch_info[2].tx )/2 ;
  	tx2 =(ix_cal_touch_info[1].tx + ix_cal_touch_info[3].tx )/2 ;
  	sx1 =(ix_cal_touch_info[0].sx + ix_cal_touch_info[2].sx )/2 ;
  	sx2 =(ix_cal_touch_info[1].sx + ix_cal_touch_info[3].sx )/2 ;
  
  	ty1 =(ix_cal_touch_info[0].ty + ix_cal_touch_info[1].ty )/2 ;
  	ty2 =(ix_cal_touch_info[2].ty + ix_cal_touch_info[3].ty )/2 ;
  	sy1 =(ix_cal_touch_info[0].sy + ix_cal_touch_info[1].sy )/2 ;
  	sy2 =(ix_cal_touch_info[2].sy + ix_cal_touch_info[3].sy )/2 ;
  
  
  #if 0//wj@@test-touch
  	ix_adjust_touch_info.xa = ((tx2 -tx1)*IX_CAL_TOUCH_INFO_OFSSET) /(sx2 - sx1);
  	ix_adjust_touch_info.xb = tx1 -(( ix_adjust_touch_info.xa * sx1)/IX_CAL_TOUCH_INFO_OFSSET) ;
  
  	ix_adjust_touch_info.ya = ((ty2 -ty1)*IX_CAL_TOUCH_INFO_OFSSET )/(sy2 - sy1);
  	ix_adjust_touch_info.yb = ty1 -(( ix_adjust_touch_info.ya * sy1)/IX_CAL_TOUCH_INFO_OFSSET) ;
  #else
      ix_adjust_touch_info.xa = ((sx1 - sx2) * IX_CAL_TOUCH_INFO_OFSSET) /(tx1 - tx2);
      ix_adjust_touch_info.xb = (sx1 * IX_CAL_TOUCH_INFO_OFSSET) - (ix_adjust_touch_info.xa * tx1) ;
  
      ix_adjust_touch_info.ya = ((sy1 - sy2) * IX_CAL_TOUCH_INFO_OFSSET )/(ty1 - ty2);
      ix_adjust_touch_info.yb = (sy1 * IX_CAL_TOUCH_INFO_OFSSET) - (ix_adjust_touch_info.ya * ty1) ;
  
  
      ix_adjust_touch_flag = FLAG_SET;
  
  #endif
  
  	return 0;
  }
  
  //--------------------------------------------------------------

  // 설명 : 이벤트 장치에 사용자가 직접 이벤트 정보를 넣어서 이벤트를 발생시킨다.
  // 주의 :

  // imesu 2008-02-20
  //--------------------------------------------------------------
  //------------------------------------------------------------------------------

  /** @brief 이벤트 장치에 사용자가 직접 이벤트 정보를 넣어서 이벤트를 발생시킨다.

      @param
      @return

      @remark 현재 장치를 구별할 방법에 없어서 모든 장치 이벤트 핸들러에 쓴다.
  //      : 장치를 구별할 방업에 생기면 이부분을 ix_write_event_low()함수로 대치해서 사용하자
      @remark 현재 장치를 구별할 방법에 없어서 모든 장치 이벤트 핸들러에 쓴다.
  //      : 장치를 구별할 방업에 생기면 이부분을 ix_write_event_low()함수로 대치해서 사용하자!!

  *///----------------------------------------------------------------------------
  static int ix_write_event_bulk_low(ix_event_t *event_data)
  {

  	int flag_write_event = -1;									// ix_write_event_low 함수의 에러를 체크함

  	int lp =0;
  
  	if(event_data == NULL)	return -1;
  
  	for(lp = 0; lp < ix_mng_count; lp++)
  	{
  		if(!(ix_write_event_low(ix_mng[lp].fd, event_data )))
  		{

  			flag_write_event = 0;	//한번이라도 event write가 성공하면 에러를 무발생!

  		}
  	}
  	if(flag_write_event <0)
  	{

  		return -1;	//ix_write_event_low함수 모두 실패

  	}
  	return 0;
  
  }
  
  
  //------------------------------------------------------------------------------

  /** @brief	이벤트 장치에 사용자가 직접 이벤트 정보를 넣어서 이벤트를 발생시킨다.

      @param
      @return
      @remark
  *///----------------------------------------------------------------------------
  int ix_write_event_low(int fd, ix_event_t *event_data )
  {
  	if( fd < 0 || event_data == NULL )
  	{

  		ix_error_code = IXERR_WRITE_EVENT; 		// 에러

  		return -1;
  	}
  
  	write( fd, event_data, sizeof(ix_event_t));
  	return 0;
  }
  
  
  //------------------------------------------------------------------------------

  /** @brief	마우스 특정버튼의 Up/Down 엑션을 발생시킨다.
      @param	mouse_button	마우스 버튼으로 종류는 3가지가 있다. (IX_MOUSE_BTN_LEFT / IX_MOUSE_BTN_RIGHT /IX_MOUSE_BTN_MIDDLE)
      @param	action			마우스 버튼상태로 2가지가 있다. (IE_MOUSE_UP / IE_MOUSE_DOWN)
      @return	0	성공
      @return	-1	실패

      @remark
  *///----------------------------------------------------------------------------
  int ix_write_mouse_button_action(int mouse_button, int action)
  {
  	ix_event_t event_data;

  	//step1: event 구조체의 공통된 값 설정

      gettimeofday( &event_data.time, NULL );
  	event_data.type = EV_KEY;

  	//step2: event 구조체의 버튼 설정값 설정

  	switch(mouse_button)
  	{
  	case IX_MOUSE_BTN_LEFT:		event_data.code = BTN_LEFT;							break;
  	case IX_MOUSE_BTN_RIGHT:	event_data.code = BTN_RIGHT;						break;
  	case IX_MOUSE_BTN_MIDDLE:	event_data.code = BTN_MIDDLE;						break;

  	default:					ix_error_code   = IXERR_WRITE_MOUSE_BUTTON_EVENT; 	return -1;	// 에러

  	}

  	//step3: event 구조체의 버튼 상태값 설정

  	switch(action)
  	{
  	case IE_MOUSE_DOWN:	event_data.value = IX_MOUSE_VAULE_DOWN;					break;
  	case IE_MOUSE_UP:	event_data.value = IX_MOUSE_VAULE_UP;					break;

  	default:			ix_error_code    = IXERR_WRITE_MOUSE_BUTTON_EVENT; 		return -1;	// 에러

  	}

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;

  	//step4: SYC 발생

      //gettimeofday( &event_data.time, NULL );
  
  	event_data.type  = EV_SYN;
  	event_data.code  = SYN_REPORT;
  	event_data.value = 0;

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;
  
  	return 0;
  
  }
  
  //------------------------------------------------------------------------------

  /** @brief	마우스 위치를 변경시킨후 이벤트를 발생 시킨다.
      @param	rel_x		움직일 x축 상대 좌표값
      @param	rel_y		움직일 y축 상대 좌표값
      @return	0	성공
      @return	-1	실패

      @remark
  *///----------------------------------------------------------------------------
  int ix_write_mouse_rel_move(int rel_x, int rel_y)
  {
  	ix_event_t event_data;

  	//step1: event 구조체의 공통된 값 설정

      gettimeofday( &event_data.time, NULL );
  	event_data.type = EV_REL;

  	//step2: event 구조체의 X 변경값 설정

  	event_data.code = REL_X;
  	event_data.value = rel_x;

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;

  	//step3: event 구조체의 Y 변경값 설정

  	event_data.code = REL_Y;
  	event_data.value = rel_y;

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;

  	//step4: SYC 발생

  
      //gettimeofday( &event_data.time, NULL );
  	event_data.type  = EV_SYN;
  	event_data.code  = SYN_REPORT;
  	event_data.value = 0;

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;
  
  	return 0;
  }
  //------------------------------------------------------------------------------

  /** @brief	키보드에 키 이벤트를 발생시킨 후 이벤트를 발생 시킨다.
      @param	keyboard_key	마우스 버튼으로 종류는 3가지가 있다. (IX_MOUSE_BTN_LEFT / IX_MOUSE_BTN_RIGHT /IX_MOUSE_BTN_MIDDLE)
      @param	action			키보드 버튼상태로 2가지가 있다. (IE_KEY_UP / IE_KEY_DOWN)

      @return

      @remark	keyboard_key: keyboard의 키 code를 의미함. 참고: Linux 커널소소/include/linux/input.h의 'Keys and buttons' 항목

  *///----------------------------------------------------------------------------
  int ix_write_keyboard_key_action(int keyboard_key, int action)
  {
  	ix_event_t event_data;

  	//step1: event 구조체의 공통된 값 설정

      gettimeofday( &event_data.time, NULL );
  	event_data.type = EV_KEY;

  	//step2: event 구조체의 KEY 값 설정

  	event_data.code = keyboard_key;

  	//step3: event 구조체의 액션 값 설정

  	switch(action)
  	{
  	case IE_KEY_DOWN:	event_data.value = 1;							break;
  	case IE_KEY_UP:		event_data.value = 0;							break;

  	default:			ix_error_code    = IXERR_WRITE_KEYBOARD_EVENT; 	return -1;	// 에러

  	}

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;

  	//step4: SYC 발생

      //gettimeofday( &event_data.time, NULL );
  	event_data.type  = EV_SYN;
  	event_data.code  = SYN_REPORT;
  	event_data.value = 0;

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;
  
  	return 0;
  }
  
  //--------------------------------------------------------------

  // to do list : 매크로 KEY_5넘 들은 순차적으로 증가하지 않고, 키보드 배열에 따른 순서에 따른다.
  //              그래서 switch 문에 길어 졌는데 좋은 방법이 없을까?
  // http://lxr.falinux.com/source/include/linux/input.h 에 있는 키 값을 실제 키보드 배열대로 나열되어 揚獵?

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------

  /** @brief	입력 값을 사용자가 바로 사용할 수 있는 아스키 코드로 변환하여 반환한다.
  			예를 들어 KEY_1은 0x30으로 변환하여 리턴한다.
  			Shift , ALT, CTRL키도 고려한다.

      @param
      @return
      @remark
  *///----------------------------------------------------------------------------
  static int ix_get_key_press_value(int *m_key, ix_btn_state_t button_state)
  {
  	int shift_flag = 0;
  	int alt = 0;
  	int askii = 0;
  
  	if( (button_state & IX_KEYBOARD_BTN_LEFT_SHIFT) ||	(button_state & IX_KEYBOARD_BTN_RIGHT_SHIFT) )
  	{

  		shift_flag = FLAG_SET;											// shift 가 눌려져 있으면 flag를 설정한다.

  	}
  
  	if( (button_state & IX_KEYBOARD_BTN_LEFT_ALT)||(button_state & IX_KEYBOARD_BTN_RIGHT_ALT))
  	{

  		alt = FLAG_SET;												// alt 가 눌려져 있으면 flag를 설정한다.

  	}
  
  	for(askii =0 ; askii <128 ;askii ++)
  	{
  		if(ix_askii[askii] == *m_key)
  		{
  			if(shift_flag == FLAG_SET ||ix_capslock_flag == FLAG_SET)
  			{

  				if(askii >= 0x41 && askii <=0x5a)	*m_key = askii+0x20;	// shift 가 눌리면 소문자.

  			}
  			else
  			{

  				*m_key = askii;												// 나머지는 전부 아스키 코드표에 있다.

  			}
  			break;
  		}
  	}
  
  	//printf(">> 0x%x
  ", *m_key);
  	shift_flag	= FLAG_RELEASE;
  	alt			= FLAG_RELEASE;
  	return 0;
  }
  /*
  //--------------------------------------------------------------

  // 설명 : 터치 스크린 보정된 위치값을 얻어 온다.

  // imesu 2009-02-20
  //--------------------------------------------------------------
  
  int ix_touch_calcurator(int *x, int *y)
  {
  	int tx =0;
  	int ty =0;
  
  	int sx = 0;
  	int sy = 0;

  	ix_get_mouse_position(&tx,&ty);							// 보정전의 터치스크린 값을 얻어 온다.

  
  //	printf("ix_adjust_touch_info.xa:%d ",ix_adjust_touch_info.xa);
  //	printf("ix_adjust_touch_info.xb:%d ",ix_adjust_touch_info.xb);
  //	printf("ix_adjust_touch_info.ya:%d ",ix_adjust_touch_info.ya);
  //	printf("ix_adjust_touch_info.yb:%d ",ix_adjust_touch_info.yb);

  	if(ix_adjust_touch_info.xa ==0)	return -1;				// 분모가 0이면 에러다.

  
  	sx = (tx-ix_adjust_touch_info.xb)/ix_adjust_touch_info.xa;
  	if(sx <= 0)
  	{
  		sx =0;
  	}
  	else if(sx >= ix_sreen_x_max)
  	{
  		sx = ix_sreen_x_max;
  	}

  	if(ix_adjust_touch_info.ya ==0)	return -1;				// 분모가 0이면 에러다.

  
  	sy = (ty-ix_adjust_touch_info.yb)/ix_adjust_touch_info.ya;
  	if(sy <= 0)
  	{
  		sy =0;
  	}
  	else if(sy >= ix_sreen_x_max)
  	{
  		sy = ix_sreen_x_max;
  	}
  	*x = sx;
  	*y = sy;
  
  	return 0;
  }
  */
  
  //------------------------------------------------------------------------------

  /** @brief	가상 키보드에서 받은 입력을 , 실제 입력 값으로 변환 ( 아스키 -> KEY_XX)
      @param	 key :  아스키 코드값을 입력 받는다.

      @return

      @remark	인자로 문자 1개 만 보낸다.
      		사용법 ix_write_key_press('A');  ix_write_key_press(3)
      		소문자 처리를 추가적으로 해야한다.

  *///----------------------------------------------------------------------------
  int ix_write_key_char_press(char key)
  {
  	int key_xxx =0;
  	ix_event_t event_data;
  
  	if(key < 0 )	return -1;
  	if(key >128)	return -1;

  	// 소문자가 들어 오면 소문자 처리

  	if(0x61 <= key  && key <=0x7a)
  	{
  		ix_button_state |= IX_KEYBOARD_NUMLOCK;
  	}
  	else
  	{

  		ix_button_state &= ~IX_KEYBOARD_NUMLOCK;	// 키보드 왼쪽 shitf 버튼이 눌림 해?

  //
  	}
  
  	key_xxx = ix_askii[(int)key];
  
  //	printf("key_xxx :%d , key_low:%d " ,key_xxx, key);

  	//step1: event 구조체의 공통된 값 설정

      gettimeofday( &event_data.time, NULL );
  	event_data.type = EV_KEY;

  	//step2: event 구조체의 KEY 값 설정

  	event_data.code = key_xxx;

  	//step3: event 구조체의 액션 값 설정

  	event_data.value = 1;

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;

  	//step4: SYC 발생

      //gettimeofday( &event_data.time, NULL );
  	event_data.type  = EV_SYN;
  	event_data.code  = SYN_REPORT;
  	event_data.value = 0;

  	// 이벤트를 모든 핸들러에 쓴다. ... 나중에 장치 구별이 되면, 해당 핸들러에만 쓰게 수정하자.!!

  	if(ix_write_event_bulk_low(&event_data) <0)		return -1;
  
  	if(ix_write_keyboard_key_action(key_xxx, IE_KEY_UP) <0 ) return -1;
  
  	return 0;
  }
  
  
  //--------------------------------------------------------------

  // 설명 :

  // imesu 2009-02-20

  // 인자 :
  //         str :  문자열을 입력 받는다.
  //         size : 문자열의 사이즈
  // 사용법 : ix_write_key_press('ABC', 3);

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------

  /** @brief	가상 키보드에서 받은 입력열을 , 실제 입력 값으로 변환 ( 아스키 -> KEY_XX)

      @param
      @return
      @remark	ix_write_key_press('ABC', 3);
  *///----------------------------------------------------------------------------
  int ix_write_key_string_press(char *str, int size)
  {
  	return 0;
  
  }
  
  
  
  //--------------------------------------------------------------

  // 설명 :

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------
  /** @brief
      @param
      @return
      @remark
  *///----------------------------------------------------------------------------
  int ix_get_touch(int x_tch, int y_tch, int *x_scr_ptr, int *y_scr_ptr)
  {
      int   x, y;
  
  #if 1//reserved
      if ( !ix_adjust_touch_flag )
      {
          *x_scr_ptr = x_tch;
          *y_scr_ptr = y_tch;
  
          return 1;
      }
  #endif
  
      x = (ix_adjust_touch_info.xa * x_tch + ix_adjust_touch_info.xb) / IX_CAL_TOUCH_INFO_OFSSET;
      y = (ix_adjust_touch_info.ya * y_tch + ix_adjust_touch_info.yb) / IX_CAL_TOUCH_INFO_OFSSET;
  
      if( x < 0 )                 x = 0;
      if( y < 0 )                 y = 0;
  
      if(x >= ix_sreen_x_max)     x = ix_sreen_x_max;
      if(y >= ix_sreen_y_max)     y = ix_sreen_y_max;
  
      *x_scr_ptr = (int)x;
      *y_scr_ptr = (int)y;
  
      return 1;
  }

  #if 1//검토 예정

  
  //------------------------------------------------------------------------------

  /** @brief	ix_adjust_touch_info 값을 설정 한다

      @param
      @return
      @remark
  *///----------------------------------------------------------------------------
  int ix_set_touch( ix_adjust_touch_info_t *info )
  {
  
      ix_adjust_touch_info.xa = info->xa;
      ix_adjust_touch_info.xb = info->xb;
      ix_adjust_touch_info.ya = info->ya;
      ix_adjust_touch_info.yb = info->yb;
  
      ix_adjust_touch_flag = FLAG_SET;
  
  	return 1;
  }
  
  //------------------------------------------------------------------------------

  /** @brief	ix_adjust_touch_info 값을 가져온다

      @param
      @return
      @remark
  *///----------------------------------------------------------------------------
  int ix_get_touch_info( ix_adjust_touch_info_t *info )
  {
      *info = ix_adjust_touch_info;
  
  	return 1;
  }
  
  
  //------------------------------------------------------------------------------

  /** @brief ix_adjust_touch_info 값을 프린트 한다

      @param
      @return

      @remark 1	프린트 성공

  *///----------------------------------------------------------------------------
  int ix_print_touch( void )
  {
  
      printf( "ix_adjust_touch_info = %d 
  ", ix_adjust_touch_info.xa );
      printf( "ix_adjust_touch_info = %d 
  ", ix_adjust_touch_info.xb );
      printf( "ix_adjust_touch_info = %d 
  ", ix_adjust_touch_info.ya );
      printf( "ix_adjust_touch_info = %d 
  ", ix_adjust_touch_info.yb );
  
  	return 1;
  }
  
  //--------------------------------------------------------------

  // 설명 :

  //--------------------------------------------------------------
  //------------------------------------------------------------------------------

  /** @brief	ix_adjust_touch_info 값을 설정하기 위한 초기화

      @return

   @brief	ix_adjust_touch_info 값을 설정하기 위한 초기화

      @return
  *///----------------------------------------------------------------------------
  int ix_adjust_touch_init( void )
  {
      ix_adjust_touch_flag = 0;
  }
  #endif