开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
wgui_categories_inputs.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：1705k
源码类别：

MTK

开发平台：

C/C++

wgui_categories_inputs.c：源码内容
  1.         tmp_flags &= ~UI_MULTI_LINE_INPUT_BOX_STATE_MULTITAP;
  2.         //barcode
  3.         if (MMI_multiline_inputbox.hilite_cb == NULL)
  4.         {
  5.         tmp_flags &= ~UI_MULTI_LINE_INPUT_BOX_WORD_HIGHLIGHT;
  6.         }
  7.         /* MTK end */
  8.         for (i = 0; i < sizeof(U32); i++)
  9.         {
  10.             memcpy((U8*) (&h->flags) + i, (U8*) (&tmp_flags) + i, 1);
  11.         }
  12.         /* Calvin end */
  14.         h->UCS2_count = (S16) MMI_multiline_inputbox.UCS2_count;
  15.     #if defined(__MMI_TOUCH_SCREEN__)
  16.         /* W05.41 Do not Strore Virtual Keyboard into History when View Mode */
  17.         if (!(MMI_multiline_inputbox.flags & UI_MULTI_LINE_INPUT_BOX_VIEW_MODE))
  18.         {
  19.             if (GUI_VIRTUAL_KEYBOARD_MAX_LANG == mmi_pen_editor_history_vk_lang_type())
  20.             {
  21.                 h->vk_lang_type = MMI_virtual_keyboard.lang_type;
  22.             }
  23.             else
  24.             {
  25.                 h->vk_lang_type = mmi_pen_editor_history_vk_lang_type();
  26.             }
  27.         }
  28.         else
  29.         {
  30.             h->vk_lang_type = GUI_VIRTUAL_KEYBOARD_EMPTY_TRAY;
  31.         }
  32.     #endif /* defined(__MMI_TOUCH_SCREEN__) */ 
  33.         h->state = (S8) - 1;    /* MTK 2004-02-13 Wilson, Initialize history buffer state */
  34.     }
  35. }
  37. /* MTK 2004-02-13 Wilson, Set and Get state of multiine inputbox history buffer */
  40. /*****************************************************************************
  41.  * FUNCTION
  42.  *  set_multiline_inputbox_category_history_state
  43.  * DESCRIPTION
  44.  *  Sets the state of history data for state list
  45.  * PARAMETERS
  46.  *  history_ID          [IN]        Is the ID used by category screens
  47.  *  history_buffer      [IN]        Is the buffer into which history data is written
  48.  *  state               [IN]        Is the state to be set to state list
  49.  * RETURNS
  50.  *  void
  51.  *****************************************************************************/
  52. void set_multiline_inputbox_category_history_state(U16 history_ID, U8 *history_buffer, S8 state)
  53. {
  54.     /*----------------------------------------------------------------*/
  55.     /* Local Variables                                                */
  56.     /*----------------------------------------------------------------*/
  58.     /*----------------------------------------------------------------*/
  59.     /* Code Body                                                      */
  60.     /*----------------------------------------------------------------*/
  61.     if (history_buffer != NULL)
  62.     {
  63.         multiline_inputbox_category_history *h = (multiline_inputbox_category_history*) history_buffer;
  65.         h->state = state;
  66.     }
  67. }
  70. /*****************************************************************************
  71.  * FUNCTION
  72.  *  get_multiline_inputbox_category_history_state
  73.  * DESCRIPTION
  74.  *  Gets the state of history data for state list
  75.  * PARAMETERS
  76.  *  history_ID          [IN]        Is the ID used by category screens
  77.  *  history_buffer      [IN]        Is the buffer into which history data is written
  78.  *  state(?)            [IN]        Is the state to be set to state list
  79.  * RETURNS
  80.  *  void
  81.  *****************************************************************************/
  82. S8 get_multiline_inputbox_category_history_state(U16 history_ID, U8 *history_buffer)
  83. {
  84.     /*----------------------------------------------------------------*/
  85.     /* Local Variables                                                */
  86.     /*----------------------------------------------------------------*/
  88.     /*----------------------------------------------------------------*/
  89.     /* Code Body                                                      */
  90.     /*----------------------------------------------------------------*/
  91.     if (history_buffer != NULL)
  92.     {
  93.         multiline_inputbox_category_history *h = (multiline_inputbox_category_history*) history_buffer;
  95.         return h->state;
  96.     }
  97.     return (S8) - 1;
  98. }
  100. /* MTK END */
  102. /* Start Dialer Input Boxs */
  104. extern stFontAttribute wgui_dialer_box_f1;
  105. extern stFontAttribute wgui_dialer_box_f2;
  107. /* struxcture handle star key input in dialer box */
  108. multitap_input wgui_dialer_box_star_key_handler;
  110. #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  111. multitap_input wgui_dialer_box_zero_key_handler;
  112. #endif 
  113. U8 wgui_dialer_box_active_multitap = WGUI_DIALER_BOX_ACTIVE_MULTITAP_NONE;
  115. #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  116. UI_character_type wgui_dialer_box_star_key_string[] = { '*', 'p', 'w', '' };
  118. /* MTK Elvis for multitap zero Key */
  119. #ifdef __MMI_MULTITAP_KEY_0__
  120. UI_character_type wgui_dialer_box_zero_key_string[] = { '+', 'p', 'w', '' };
  121. #else 
  122. UI_character_type wgui_dialer_box_zero_key_string[] = { '0', '+', '' };
  123. #endif 
  124. /* MTK end */
  125. #else /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  126. UI_character_type wgui_dialer_box_star_key_string[] = { '*', '+', 'p', 'w', '' };
  127. #endif /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  128. /*----------------------------------------------------------------------------
  129. Function:         wgui_dialer_inputbox_RSK_function
  130. Description:      Function pointer store the address of RSK function handler
  131. Input Parameters: void
  132. Output Parameters:   none
  133. Returns:       none
  134. ----------------------------------------------------------------------------*/
  135. void (*wgui_dialer_inputbox_RSK_function) (void) = NULL;
  136. U8 wgui_dialer_inputbox_RSK_label_clear = 0;
  138. /* store the string of RSK of dialer input box */
  139. UI_string_type wgui_dialer_inputbox_RSK_label_string;
  141. /* store the icon of RSK of dialer input box */
  142. PU8 wgui_dialer_inputbox_RSK_label_icon;
  144. /* used to keep tarck of decimal input in dialer input box */
  145. U8 wgui_dialer_inputbox_decimal_flag = 0;
  147. /* used to chekc if decimal input is enable for dialer box or not */
  148. U8 wgui_dialer_inputbox_decimal_input_mode_flag = 0;
  150. #if(0)
  152. /* Dependent on the width of the Input box.
  153. Values must be changed from platform to platform */
  155. void dialer_input_box_change_callback(void)
  156. { s32 text_length=pixtel_UI_dialer_input_box_get_text_length(&MMI_dialer_inputbox);
  157. UI_font_type f=MMI_dialer_inputbox.text_font;
  158. if(f==&wgui_dialer_box_f1)
  159. { if(text_length>18) MMI_dialer_inputbox.text_font=(&wgui_dialer_box_f2);
  160. }
  161. else if(f==&wgui_dialer_box_f2)
  162. { if(text_length<=18) MMI_dialer_inputbox.text_font=(&wgui_dialer_box_f1);
  163. else if(text_length>30) MMI_dialer_inputbox.text_font=(&wgui_dialer_box_f3);
  164. }
  165. else if(f==&wgui_dialer_box_f3)
  166. { if(text_length<=30) MMI_dialer_inputbox.text_font=(&wgui_dialer_box_f2);
  167. }
  168. }
  170. #endif /* (0) */ 
  173. /*****************************************************************************
  174.  * FUNCTION
  175.  *  dialer_input_box_change_callback
  176.  * DESCRIPTION
  177.  *  change callback funtion of dialer input box
  178.  * PARAMETERS
  179.  *  void
  180.  * RETURNS
  181.  *  void
  182.  *****************************************************************************/
  183. void dialer_input_box_change_callback(void)
  184. {
  185.     /*----------------------------------------------------------------*/
  186.     /* Local Variables                                                */
  187.     /*----------------------------------------------------------------*/
  188.     /* MTK Elvis to change the font size while the dialer box is too small to insert chars */
  189.     S32 text_width = 0, text_height = 0, i = 0, j = 0;
  190.     static S32 max_char_height_in_dialer_box = 0;
  191.     UI_buffer_type b_text;
  192.     S32 text_length;
  193.     UI_character_type ch;
  195.     /*----------------------------------------------------------------*/
  196.     /* Code Body                                                      */
  197.     /*----------------------------------------------------------------*/
  198.     MMI_dialer_inputbox.text_font = (&wgui_dialer_box_f1);
  200.     gui_lock_double_buffer();
  201.     MMI_dialer_inputbox.flags |= UI_DIALER_INPUT_BOX_DISABLE_DRAW;
  202.     gui_show_dialer_input_box(&MMI_dialer_inputbox);
  203.     MMI_dialer_inputbox.flags &= ~UI_DIALER_INPUT_BOX_DISABLE_DRAW;
  204.     gui_unlock_double_buffer();
  206.     /* f=MMI_dialer_inputbox.text_font; */
  207.     gui_measure_string((UI_string_type) MMI_dialer_inputbox.text, &text_width, &text_height);
  208.     text_length = gui_dialer_input_box_get_text_length(&MMI_dialer_inputbox);
  209.     b_text = MMI_dialer_inputbox.text;
  210.     if (max_char_height_in_dialer_box < text_height)
  211.     {
  212.         max_char_height_in_dialer_box = text_height;
  213.     }
  215.     text_width = 0;
  216.     for (i = 0; i < text_length; i++)
  217.     {
  218.         UI_STRING_GET_NEXT_CHARACTER(b_text, ch);
  219.         text_width += gui_get_character_width(ch);
  220.         text_width += MMI_dialer_inputbox.text_gap;
  221.         if (text_width + 1 > MMI_dialer_inputbox.width)
  222.         {
  223.             if (max_char_height_in_dialer_box > 0)
  224.             {
  225.                 if (++j >= ((MMI_dialer_inputbox.height / (max_char_height_in_dialer_box + 1))))
  226.                 {
  227.                     MMI_dialer_inputbox.text_font = (&wgui_dialer_box_f2);
  229.                     break;
  230.                 }
  231.                 else
  232.                 {
  233.                     text_width = gui_get_character_width(ch);
  234.                     text_width += MMI_dialer_inputbox.text_gap;
  235.                 }
  236.             }
  238.         }
  240.     }
  241. }
  243. void dialer_inputbox_complete_multitap_star_key(void);
  245. #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  246. void dialer_inputbox_complete_multitap_zero_key(void);
  247. #endif 
  250. /*****************************************************************************
  251.  * FUNCTION
  252.  *  dialer_inputbox_handle_multitap_complete
  253.  * DESCRIPTION
  254.  *  
  255.  * PARAMETERS
  256.  *  type        [IN]        
  257.  * RETURNS
  258.  *  void
  259.  *****************************************************************************/
  260. extern void MMI_key_0_down(void);
  261. extern void MMI_key_0_up(void);
  262. extern pBOOL isInCall(void);
  265. void dialer_inputbox_handle_multitap_complete(S32 type)
  266. {
  267.     /*----------------------------------------------------------------*/
  268.     /* Local Variables                                                */
  269.     /*----------------------------------------------------------------*/
  271.     /*----------------------------------------------------------------*/
  272.     /* Code Body                                                      */
  273.     /*----------------------------------------------------------------*/
  274.     if (wgui_dialer_box_active_multitap != WGUI_DIALER_BOX_ACTIVE_MULTITAP_NONE)
  275.     {
  276.         switch (wgui_dialer_box_active_multitap)
  277.         {
  278.             case WGUI_DIALER_BOX_ACTIVE_MULTITAP_STAR_KEY:
  279.                 if (type == WGUI_DIALER_BOX_ACTIVE_MULTITAP_STAR_KEY)
  280.                 {
  281.                     return;
  282.                 }
  283.                 if (MMI_dialer_inputbox.flags & UI_DIALER_INPUT_BOX_STATE_MULTITAP)
  284.                 {
  285.                     gui_cancel_timer(dialer_inputbox_complete_multitap_star_key);
  286.                     gui_multitap_input_complete(&wgui_dialer_box_star_key_handler);
  287.                 }
  288.                 break;
  289.             #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  290.             case WGUI_DIALER_BOX_ACTIVE_MULTITAP_ZERO_KEY:
  291.                 if (type == WGUI_DIALER_BOX_ACTIVE_MULTITAP_ZERO_KEY)
  292.                 {
  293.                     return;
  294.                 }
  295.                 if (MMI_dialer_inputbox.flags & UI_DIALER_INPUT_BOX_STATE_MULTITAP)
  296.                 {
  297.                     gui_cancel_timer(dialer_inputbox_complete_multitap_zero_key);
  298.                     gui_multitap_input_complete(&wgui_dialer_box_zero_key_handler);
  299.                     /* MTK Elvis to store the zero key hander for idleScreenDigitHandler.... */
  300.                     if (isInCall())
  301.                     {
  302.                         wgui_key_handlers[KEY_0][KEY_EVENT_DOWN] = storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_DOWN];
  303.                         wgui_key_handlers[KEY_0][KEY_EVENT_UP] = storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_UP];
  304.                     }
  305.                     else
  306.                     {
  307.                         SetKeyHandler(storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_DOWN], KEY_0, KEY_EVENT_DOWN);
  308.                         SetKeyHandler(storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_UP], KEY_0, KEY_EVENT_UP);
  309.                     }
  310.                     /* SetKeyHandler(MMI_key_0_down,KEY_0,KEY_EVENT_DOWN); */
  311.                 }
  312.                 break;
  313.             #endif /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  314.         }
  315.         wgui_dialer_box_active_multitap = WGUI_DIALER_BOX_ACTIVE_MULTITAP_NONE;
  316.     }
  317. }
  320. /*****************************************************************************
  321.  * FUNCTION
  322.  *  dialer_inputbox_handle_key_down
  323.  * DESCRIPTION
  324.  *  Function handles a key down wvwnt of dialer input box
  325.  * PARAMETERS
  326.  *  k           [IN]        
  327.  *  S32(?)      [IN]        MMI_key_code_type :- Key code
  328.  * RETURNS
  329.  *  void
  330.  *****************************************************************************/
  331. void dialer_inputbox_handle_key_down(MMI_key_code_type k)
  332. {
  333.     /*----------------------------------------------------------------*/
  334.     /* Local Variables                                                */
  335.     /*----------------------------------------------------------------*/
  337.     /*----------------------------------------------------------------*/
  338.     /* Code Body                                                      */
  339.     /*----------------------------------------------------------------*/
  340.     dialer_inputbox_handle_multitap_complete(WGUI_DIALER_BOX_ACTIVE_MULTITAP_ANY);
  341.     dialer_inputbox_direct_input((UI_character_type) ('0' + k));
  342. }
  345. /*****************************************************************************
  346.  * FUNCTION
  347.  *  dialer_inputbox_complete_multitap_star_key
  348.  * DESCRIPTION
  349.  *  Function handles a multitap star key down input and draw the dialer input box
  350.  * PARAMETERS
  351.  *  void
  352.  *  noen(?)     [IN]        
  353.  * RETURNS
  354.  *  void
  355.  *****************************************************************************/
  356. void dialer_inputbox_complete_multitap_star_key(void)
  357. {
  358.     /*----------------------------------------------------------------*/
  359.     /* Local Variables                                                */
  360.     /*----------------------------------------------------------------*/
  362.     /*----------------------------------------------------------------*/
  363.     /* Code Body                                                      */
  364.     /*----------------------------------------------------------------*/
  365.     gui_multitap_input_complete(&wgui_dialer_box_star_key_handler);
  367.     mmi_idle_star_key_disable_long_press(); /* special handler for star key pressed in touch screen dial pad */
  368. }
  371. /*****************************************************************************
  372.  * FUNCTION
  373.  *  dialer_inputbox_handle_multitap_star_key_down
  374.  * DESCRIPTION
  375.  *  Function handles a multitap star key down input of dialer box
  376.  * PARAMETERS
  377.  *  void
  378.  * RETURNS
  379.  *  void
  380.  *****************************************************************************/
  381. void dialer_inputbox_handle_multitap_star_key_down(void)
  382. {
  383.     /*----------------------------------------------------------------*/
  384.     /* Local Variables                                                */
  385.     /*----------------------------------------------------------------*/
  387.     /*----------------------------------------------------------------*/
  388.     /* Code Body                                                      */
  389.     /*----------------------------------------------------------------*/
  390.     dialer_inputbox_handle_multitap_complete(WGUI_DIALER_BOX_ACTIVE_MULTITAP_STAR_KEY);
  391.     wgui_dialer_box_active_multitap = WGUI_DIALER_BOX_ACTIVE_MULTITAP_STAR_KEY;
  392.     gui_change_multitap_input_state(&wgui_dialer_box_star_key_handler);
  393.     if (MMI_dialer_inputbox.text_length <= 2)
  394.     {
  395.         gui_start_timer(MMI_MULTITAP_TIMEOUT, dialer_inputbox_complete_multitap_star_key);
  396.     }
  397. }
  400. /*****************************************************************************
  401.  * FUNCTION
  402.  *  dialer_inputbox_handle_multitap_star_key_up
  403.  * DESCRIPTION
  404.  *  Function handles a multitap star key up input of dialer box
  405.  * PARAMETERS
  406.  *  void
  407.  * RETURNS
  408.  *  void
  409.  *****************************************************************************/
  410. void dialer_inputbox_handle_multitap_star_key_up(void)
  411. {
  412.     /*----------------------------------------------------------------*/
  413.     /* Local Variables                                                */
  414.     /*----------------------------------------------------------------*/
  416.     /*----------------------------------------------------------------*/
  417.     /* Code Body                                                      */
  418.     /*----------------------------------------------------------------*/
  419.     gui_start_timer(MMI_MULTITAP_TIMEOUT, dialer_inputbox_complete_multitap_star_key);
  420. }
  422. #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  425. /*****************************************************************************
  426.  * FUNCTION
  427.  *  dialer_inputbox_complete_multitap_zero_key
  428.  * DESCRIPTION
  429.  *  
  430.  * PARAMETERS
  431.  *  void
  432.  * RETURNS
  433.  *  void
  434.  *****************************************************************************/
  435. void dialer_inputbox_complete_multitap_zero_key(void)
  436. {
  437.     /*----------------------------------------------------------------*/
  438.     /* Local Variables                                                */
  439.     /*----------------------------------------------------------------*/
  441.     /*----------------------------------------------------------------*/
  442.     /* Code Body                                                      */
  443.     /*----------------------------------------------------------------*/
  444.     gui_multitap_input_complete(&wgui_dialer_box_zero_key_handler);
  445. #ifdef __MMI_MULTITAP_KEY_0__
  446.     /* MTK Elvis to store the zero key hander for idleScreenDigitHandler.... */
  447.     if (isInCall())
  448.     {
  449.         wgui_key_handlers[KEY_0][KEY_EVENT_DOWN] = storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_DOWN];
  450.         wgui_key_handlers[KEY_0][KEY_EVENT_UP] = storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_UP];
  451.     }
  452.     else
  453.     {
  454.         SetKeyHandler(storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_DOWN], KEY_0, KEY_EVENT_DOWN);
  455.         SetKeyHandler(storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_UP], KEY_0, KEY_EVENT_UP);
  456.     }
  457.     /* MTK end */
  458. #endif /* __MMI_MULTITAP_KEY_0__ */ 
  459. }
  462. /*****************************************************************************
  463.  * FUNCTION
  464.  *  dialer_inputbox_handle_multitap_zero_key_down
  465.  * DESCRIPTION
  466.  *  Function handles a zero key down input of dialer box
  467.  * PARAMETERS
  468.  *  void
  469.  * RETURNS
  470.  *  void
  471.  *****************************************************************************/
  472. void dialer_inputbox_handle_multitap_zero_key_down(void)
  473. {
  474.     /*----------------------------------------------------------------*/
  475.     /* Local Variables                                                */
  476.     /*----------------------------------------------------------------*/
  478.     /*----------------------------------------------------------------*/
  479.     /* Code Body                                                      */
  480.     /*----------------------------------------------------------------*/
  481.     dialer_inputbox_handle_multitap_complete(WGUI_DIALER_BOX_ACTIVE_MULTITAP_ZERO_KEY);
  482.     wgui_dialer_box_active_multitap = WGUI_DIALER_BOX_ACTIVE_MULTITAP_ZERO_KEY;
  483.     gui_change_multitap_input_state(&wgui_dialer_box_zero_key_handler);
  484.     if (MMI_dialer_inputbox.text_length <= 2)
  485.     {
  486.         gui_start_timer(MMI_MULTITAP_TIMEOUT, dialer_inputbox_complete_multitap_zero_key);
  487.     }
  488. }
  491. /*****************************************************************************
  492.  * FUNCTION
  493.  *  dialer_inputbox_handle_multitap_zero_key_up
  494.  * DESCRIPTION
  495.  *  Function handles a zero key up input of dialer box
  496.  * PARAMETERS
  497.  *  void
  498.  * RETURNS
  499.  *  void
  500.  *****************************************************************************/
  501. void dialer_inputbox_handle_multitap_zero_key_up(void)
  502. {
  503.     /*----------------------------------------------------------------*/
  504.     /* Local Variables                                                */
  505.     /*----------------------------------------------------------------*/
  507.     /*----------------------------------------------------------------*/
  508.     /* Code Body                                                      */
  509.     /*----------------------------------------------------------------*/
  510. #ifdef __MMI_MULTITAP_KEY_0__
  511.     gui_start_timer(MMI_MULTITAP_TIMEOUT + 400, dialer_inputbox_complete_multitap_zero_key);
  512. #else 
  513.     gui_start_timer(MMI_MULTITAP_TIMEOUT, dialer_inputbox_complete_multitap_zero_key);
  514. #endif 
  515.     /* MTK Terry for Cannon_plus #3504 */
  516.     if (storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_UP])
  517.     {
  518.         (*storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_UP]) ();
  519.     }
  520.     /* MTK end */
  521. }
  523. #endif /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  526. /*****************************************************************************
  527.  * FUNCTION
  528.  *  dialer_inputbox_handle_zero_key_long_press
  529.  * DESCRIPTION
  530.  *  Function handles a zero key long press  input of dialer box
  531.  * PARAMETERS
  532.  *  void
  533.  * RETURNS
  534.  *  void
  535.  *****************************************************************************/
  536. void dialer_inputbox_handle_zero_key_long_press(void)
  537. {
  538. #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  539.     /*----------------------------------------------------------------*/
  540.     /* Local Variables                                                */
  541.     /*----------------------------------------------------------------*/
  543.     /*----------------------------------------------------------------*/
  544.     /* Code Body                                                      */
  545.     /*----------------------------------------------------------------*/
  546.     SetKeyHandler(dialer_inputbox_handle_multitap_zero_key_down, KEY_0, KEY_REPEAT);
  547. #else /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  548.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_REPEAT);
  549. #endif /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  551.     dialer_inputbox_delete_character();
  552.     /* MTK added by JL 031112, for multitap key register */
  553. #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  554.     dialer_inputbox_handle_multitap_zero_key_down();
  555.     /* MTK Elvis to store the zero key hander for idleScreenDigitHandler.... */
  556.     if (isInCall())
  557.     {
  558.         storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_DOWN] = wgui_key_handlers[KEY_0][KEY_EVENT_DOWN];
  559.         storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_UP] = wgui_key_handlers[KEY_0][KEY_EVENT_UP];
  560.         wgui_key_handlers[KEY_0][KEY_EVENT_DOWN] = dialer_inputbox_handle_multitap_zero_key_down;
  561.         wgui_key_handlers[KEY_0][KEY_EVENT_UP] = dialer_inputbox_handle_multitap_zero_key_up;
  562.     }
  563.     else
  564.     {
  565.         storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_DOWN] = currKeyFuncPtrs[KEY_0][KEY_EVENT_DOWN];
  566.         storeZeroKeyFuncPtrs[KEY_0][KEY_EVENT_UP] = currKeyFuncPtrs[KEY_0][KEY_EVENT_UP];
  567.         SetKeyHandler(dialer_inputbox_handle_multitap_zero_key_down, KEY_0, KEY_EVENT_DOWN);
  568.         SetKeyHandler(dialer_inputbox_handle_multitap_zero_key_up, KEY_0, KEY_EVENT_UP);
  569.     }
  570.     /* MTK end */
  571. #endif /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  572.     /* MTK end */
  574. }
  578. /*****************************************************************************
  579.  * FUNCTION
  580.  *  dialer_inputbox_handle_hash_key_down
  581.  * DESCRIPTION
  582.  *  Function handles a hash key down input of dialer box
  583.  * PARAMETERS
  584.  *  void
  585.  * RETURNS
  586.  *  void
  587.  *****************************************************************************/
  588. void dialer_inputbox_handle_hash_key_down(void)
  589. {
  590.     /*----------------------------------------------------------------*/
  591.     /* Local Variables                                                */
  592.     /*----------------------------------------------------------------*/
  594.     /*----------------------------------------------------------------*/
  595.     /* Code Body                                                      */
  596.     /*----------------------------------------------------------------*/
  597.     dialer_inputbox_handle_multitap_complete(WGUI_DIALER_BOX_ACTIVE_MULTITAP_ANY);
  598.     dialer_inputbox_direct_input((UI_character_type) '#');
  599. }
  602. /*****************************************************************************
  603.  * FUNCTION
  604.  *  dialer_inputbox_handle_star_key_down
  605.  * DESCRIPTION
  606.  *  Function handles a start key down input of dialer box
  607.  * PARAMETERS
  608.  *  void
  609.  * RETURNS
  610.  *  void
  611.  *****************************************************************************/
  612. void dialer_inputbox_handle_star_key_down(void)
  613. {
  614.     /*----------------------------------------------------------------*/
  615.     /* Local Variables                                                */
  616.     /*----------------------------------------------------------------*/
  618.     /*----------------------------------------------------------------*/
  619.     /* Code Body                                                      */
  620.     /*----------------------------------------------------------------*/
  621.     dialer_inputbox_handle_multitap_complete(WGUI_DIALER_BOX_ACTIVE_MULTITAP_ANY);
  622.     dialer_inputbox_direct_input((UI_character_type) '*');
  623. }
  626. /*****************************************************************************
  627.  * FUNCTION
  628.  *  wgui_handle_dialer_inputbox_right_softkey_down
  629.  * DESCRIPTION
  630.  *  Function handles a RSK  key down input of dialer box
  631.  * PARAMETERS
  632.  *  void
  633.  * RETURNS
  634.  *  void
  635.  *****************************************************************************/
  636. void wgui_handle_dialer_inputbox_right_softkey_down(void)
  637. {
  638.     /*----------------------------------------------------------------*/
  639.     /* Local Variables                                                */
  640.     /*----------------------------------------------------------------*/
  642.     /*----------------------------------------------------------------*/
  643.     /* Code Body                                                      */
  644.     /*----------------------------------------------------------------*/
  645.     /* MTK Elvis to complete the active multitap key */
  646.     dialer_inputbox_handle_multitap_complete(WGUI_DIALER_BOX_ACTIVE_MULTITAP_ANY);
  647.     /* MTK end */
  648.     dialer_inputbox_delete_character();
  649. }
  652. /*****************************************************************************
  653.  * FUNCTION
  654.  *  wgui_handle_dialer_inputbox_right_softkey_up
  655.  * DESCRIPTION
  656.  *  Function handles a RSK  key up input of dialer box
  657.  * PARAMETERS
  658.  *  void
  659.  * RETURNS
  660.  *  void
  661.  *****************************************************************************/
  662. void wgui_handle_dialer_inputbox_right_softkey_up(void)
  663. {
  664.     /*----------------------------------------------------------------*/
  665.     /* Local Variables                                                */
  666.     /*----------------------------------------------------------------*/
  667.     /* MTK Terry for reentry issue */
  668. #if defined(__MMI_WITH_C_KEY__)
  669.     static U8 executing = 0;
  671.     /*----------------------------------------------------------------*/
  672.     /* Code Body                                                      */
  673.     /*----------------------------------------------------------------*/
  674.     if (1 == executing)
  675.     {
  676.         return;
  677.     }
  678.     executing = 1;
  679. #endif /* defined(__MMI_WITH_C_KEY__) */ 
  680. #ifdef __MMI_MULTITAP_KEY_0__
  681.     if (wgui_dialer_box_active_multitap == WGUI_DIALER_BOX_ACTIVE_MULTITAP_ZERO_KEY)
  682.     {
  683.         gui_cancel_timer(dialer_inputbox_complete_multitap_zero_key);
  684.     }
  685. #else /* __MMI_MULTITAP_KEY_0__ */ 
  686.     if (wgui_dialer_box_active_multitap == WGUI_DIALER_BOX_ACTIVE_MULTITAP_STAR_KEY)
  687.     {
  688.         gui_cancel_timer(dialer_inputbox_complete_multitap_star_key);
  689.     }
  690. #endif /* __MMI_MULTITAP_KEY_0__ */ 
  691.     if (wgui_dialer_inputbox_RSK_function != NULL)
  692.     {
  693.         wgui_dialer_inputbox_RSK_function();
  694.     }
  695. #if defined(__MMI_WITH_C_KEY__)
  696.     executing = 0;
  697. #endif 
  698. }
  701. /*****************************************************************************
  702.  * FUNCTION
  703.  *  wgui_register_dialer_inputbox_handle_right_softkey_up
  704.  * DESCRIPTION
  705.  *  register RSK function of dialer box
  706.  * PARAMETERS
  707.  *  void
  708.  * RETURNS
  709.  *  void
  710.  *****************************************************************************/
  711. void wgui_register_dialer_inputbox_handle_right_softkey_up(void)
  712. {
  713.     /*----------------------------------------------------------------*/
  714.     /* Local Variables                                                */
  715.     /*----------------------------------------------------------------*/
  717.     /*----------------------------------------------------------------*/
  718.     /* Code Body                                                      */
  719.     /*----------------------------------------------------------------*/
  720.     set_right_softkey_function(wgui_handle_dialer_inputbox_right_softkey_up, KEY_EVENT_UP);
  721. }
  724. /*****************************************************************************
  725.  * FUNCTION
  726.  *  wgui_register_dialer_inputbox_handle_clear_key_up
  727.  * DESCRIPTION
  728.  *  register RSK function of dialer box
  729.  * PARAMETERS
  730.  *  void
  731.  * RETURNS
  732.  *  void
  733.  *****************************************************************************/
  734. void wgui_register_dialer_inputbox_handle_clear_key_up(void)
  735. {
  736.     /*----------------------------------------------------------------*/
  737.     /* Local Variables                                                */
  738.     /*----------------------------------------------------------------*/
  740.     /*----------------------------------------------------------------*/
  741.     /* Code Body                                                      */
  742.     /*----------------------------------------------------------------*/
  743.     SetKeyHandler(wgui_handle_dialer_inputbox_right_softkey_up, KEY_CLEAR, KEY_EVENT_UP);
  744. }
  747. /*****************************************************************************
  748.  * FUNCTION
  749.  *  wgui_handle_dialer_inputbox_input
  750.  * DESCRIPTION
  751.  *  handle dialer input box set RSK function of dialer box
  752.  * PARAMETERS
  753.  *  void
  754.  * RETURNS
  755.  *  void
  756.  *****************************************************************************/
  757. void wgui_handle_dialer_inputbox_input(void)
  758. {
  759.     /*----------------------------------------------------------------*/
  760.     /* Local Variables                                                */
  761.     /*----------------------------------------------------------------*/
  763.     /*----------------------------------------------------------------*/
  764.     /* Code Body                                                      */
  765.     /*----------------------------------------------------------------*/
  766.     if (gui_dialer_input_box_get_text_length(&MMI_dialer_inputbox) > 0)
  767.     {
  768.     #if defined(__MMI_WITH_C_KEY__)
  769.         if (wgui_dialer_inputbox_RSK_label_clear == 0)
  770.         {
  771.             if (wgui_inputbox_not_empty_callback != NULL)
  772.             {
  773.                 wgui_inputbox_not_empty_callback();
  774.             }
  775.             wgui_dialer_inputbox_RSK_label_clear = 1;
  776.             SetKeyHandler(wgui_handle_dialer_inputbox_right_softkey_down, KEY_CLEAR, KEY_EVENT_DOWN);
  777.             SetKeyHandler(UI_dummy_function, KEY_CLEAR, KEY_EVENT_UP);
  778.             SetKeyHandler(wgui_handle_dialer_inputbox_right_softkey_long_press, KEY_CLEAR, KEY_EVENT_LONG_PRESS);
  779.         }
  780.     #else /* defined(__MMI_WITH_C_KEY__) */ 
  781.         if (wgui_dialer_inputbox_RSK_label_clear == 0)
  782.         {
  783.             set_right_softkey_label((UI_string_type) get_string(WGUI_CATEGORY_CLEAR_STRING_ID));
  784.             set_right_softkey_icon(NULL);
  785.             if (wgui_inputbox_not_empty_callback != NULL)
  786.             {
  787.                 wgui_inputbox_not_empty_callback();
  788.             }
  789.             redraw_right_softkey();
  790.             wgui_dialer_inputbox_RSK_label_clear = 1;
  791.             set_right_softkey_function(UI_dummy_function, KEY_EVENT_UP);
  792.             set_right_softkey_function(wgui_handle_dialer_inputbox_right_softkey_down, KEY_EVENT_DOWN);
  793.         #ifdef __MMI_TOUCH_DIAL_SCREEN__
  794.             //SetRightSoftkeyFunction(TouchDialerClearKey,KEY_LONG_PRESS); 
  795.         #endif /* __MMI_TOUCH_DIAL_SCREEN__ */ 
  796.         }
  797.     #endif /* defined(__MMI_WITH_C_KEY__) */ 
  798.     }
  799.     else
  800.     {
  802.     #if defined(__MMI_WITH_C_KEY__)
  803.         if (wgui_dialer_inputbox_RSK_label_clear == 1)
  804.         {
  805.             if (wgui_inputbox_empty_callback != NULL)
  806.             {
  807.                 wgui_inputbox_empty_callback();
  808.             }
  809.             wgui_dialer_inputbox_RSK_label_clear = 0;
  810.             SetKeyHandler(UI_dummy_function, KEY_CLEAR, KEY_EVENT_DOWN);
  811.             SetKeyHandler(wgui_handle_dialer_inputbox_right_softkey_up, KEY_CLEAR, KEY_EVENT_UP);
  812.             SetKeyHandler(UI_dummy_function, KEY_CLEAR, KEY_EVENT_LONG_PRESS);
  813.             wgui_handle_dialer_inputbox_right_softkey_up();
  814.         }
  815.     #else /* defined(__MMI_WITH_C_KEY__) */ 
  816.         if (wgui_dialer_inputbox_RSK_label_clear == 1)
  817.         {
  818.         #if(DISABLE_DIALER_BACK_KEY)
  819.             set_right_softkey_function(wgui_handle_dialer_inputbox_right_softkey_up, KEY_EVENT_UP);
  820.             if (wgui_inputbox_empty_callback != NULL)
  821.             {
  822.                 wgui_inputbox_empty_callback();
  823.             }
  824.             wgui_dialer_inputbox_RSK_label_clear = 0;
  825.         #else /* (DISABLE_DIALER_BACK_KEY) */ 
  826.             set_right_softkey_label(wgui_dialer_inputbox_RSK_label_string);
  827.             set_right_softkey_icon(wgui_dialer_inputbox_RSK_label_icon);
  828.             if (wgui_inputbox_empty_callback != NULL)
  829.             {
  830.                 wgui_inputbox_empty_callback();
  831.             }
  832.             redraw_right_softkey();
  833.             wgui_dialer_inputbox_RSK_label_clear = 0;
  834.             set_right_softkey_function(wgui_register_dialer_inputbox_handle_right_softkey_up, KEY_EVENT_UP);
  835.             set_right_softkey_function(UI_dummy_function, KEY_EVENT_DOWN);
  836.         #endif /* (DISABLE_DIALER_BACK_KEY) */ 
  837.         }
  838.     #endif /* defined(__MMI_WITH_C_KEY__) */ 
  839.     }
  840. }
  843. /*****************************************************************************
  844.  * FUNCTION
  845.  *  register_dialer_inputbox_dialer_keys
  846.  * DESCRIPTION
  847.  *  register key handlers of dialer box
  848.  * PARAMETERS
  849.  *  void
  850.  * RETURNS
  851.  *  void
  852.  *****************************************************************************/
  853. void register_dialer_inputbox_dialer_keys(void)
  854. {
  855.     /*----------------------------------------------------------------*/
  856.     /* Local Variables                                                */
  857.     /*----------------------------------------------------------------*/
  859.     /*----------------------------------------------------------------*/
  860.     /* Code Body                                                      */
  861.     /*----------------------------------------------------------------*/
  862.     register_dialer_inputbox_keys();
  863.     change_multitap_mode(INPUT_MODE_123);
  864.     clear_multitap_key_handlers();
  865.     register_MMI_key_input_handler();
  866.     register_key_down_handler(dialer_inputbox_handle_key_down);
  867.     register_keyboard_input_handler(dialer_inputbox_numeric_keyboard_input_handler);
  868. #ifdef __MMI_MULTITAP_KEY_0__
  869.     SetKeyHandler(dialer_inputbox_handle_star_key_down, KEY_STAR, KEY_EVENT_DOWN);
  870. #else /* __MMI_MULTITAP_KEY_0__ */ 
  871.     SetKeyHandler(dialer_inputbox_handle_multitap_star_key_down, KEY_STAR, KEY_EVENT_DOWN);
  872.     SetKeyHandler(dialer_inputbox_handle_multitap_star_key_up, KEY_STAR, KEY_EVENT_UP);
  873. #endif /* __MMI_MULTITAP_KEY_0__ */ 
  874.     SetKeyHandler(dialer_inputbox_handle_hash_key_down, KEY_POUND, KEY_EVENT_DOWN);
  875. #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  876. #ifdef __MMI_MULTITAP_KEY_0__
  877.     SetKeyHandler(dialer_inputbox_handle_zero_key_long_press, KEY_0, KEY_EVENT_LONG_PRESS);
  878. #else /* __MMI_MULTITAP_KEY_0__ */ 
  879.     SetKeyHandler(dialer_inputbox_handle_multitap_zero_key_down, KEY_0, KEY_EVENT_DOWN);
  880.     SetKeyHandler(dialer_inputbox_handle_multitap_zero_key_up, KEY_0, KEY_EVENT_UP);
  881. #endif /* __MMI_MULTITAP_KEY_0__ */ 
  882. #endif /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  883. }
  886. /*****************************************************************************
  887.  * FUNCTION
  888.  *  wgui_dialer_validation_callback
  889.  * DESCRIPTION
  890.  *  validation function of dialer box
  891.  * PARAMETERS
  892.  *  text            [IN]        Text of dialer input box
  893.  *  cursor          [IN]        
  894.  *  text_length     [IN]        Text length
  895.  * RETURNS
  896.  *  void
  897.  *****************************************************************************/
  898. void wgui_dialer_validation_callback(UI_buffer_type text, UI_buffer_type cursor, S32 text_length)
  899. {
  900.     /*----------------------------------------------------------------*/
  901.     /* Local Variables                                                */
  902.     /*----------------------------------------------------------------*/
  904.     /*----------------------------------------------------------------*/
  905.     /* Code Body                                                      */
  906.     /*----------------------------------------------------------------*/
  907.     if (wgui_inputbox_validation_callback != NULL)
  908.     {
  909.         wgui_inputbox_validation_callback(text, cursor, text_length);
  910.     }
  911. }
  914. /*****************************************************************************
  915.  * FUNCTION
  916.  *  wgui_handle_dialer_inputbox_right_softkey_long_press
  917.  * DESCRIPTION
  918.  *  function handle long press of RSK
  919.  * PARAMETERS
  920.  *  void
  921.  * RETURNS
  922.  *  void
  923.  *****************************************************************************/
  924. void wgui_handle_dialer_inputbox_right_softkey_long_press(void)
  925. {
  926.     /*----------------------------------------------------------------*/
  927.     /* Local Variables                                                */
  928.     /*----------------------------------------------------------------*/
  930.     /*----------------------------------------------------------------*/
  931.     /* Code Body                                                      */
  932.     /*----------------------------------------------------------------*/
  933.     dialer_inputbox_delete_all_characters();
  934. }
  937. /*****************************************************************************
  938.  * FUNCTION
  939.  *  wgui_dialer_inputbox_set_border
  940.  * DESCRIPTION
  941.  *  add border for dialer inputbox
  942.  * PARAMETERS
  943.  *  is_border_existing      [IN]        
  944.  *  border_color            [IN]        
  945.  * RETURNS
  946.  *  void
  947.  *****************************************************************************/
  948. void wgui_dialer_inputbox_set_border(MMI_BOOL is_border_existing, color border_color)
  949. {
  950.     /*----------------------------------------------------------------*/
  951.     /* Local Variables                                                */
  952.     /*----------------------------------------------------------------*/
  954.     /*----------------------------------------------------------------*/
  955.     /* Code Body                                                      */
  956.     /*----------------------------------------------------------------*/
  957.     if (is_border_existing) /* draw a single border on dialer inputbox */
  958.     {
  959.         MMI_dialer_inputbox.flags |= UI_DIALER_INPUT_BOX_SHOW_BORDER;
  960.     }
  961.     else
  962.     {
  963.         MMI_dialer_inputbox.flags &= ~UI_DIALER_INPUT_BOX_SHOW_BORDER;
  964.     }
  965. }
  968. /*****************************************************************************
  969.  * FUNCTION
  970.  *  wgui_setup_dialer_inputbox
  971.  * DESCRIPTION
  972.  *  create dialer input box
  973.  * PARAMETERS
  974.  *  x                       [IN]        Start x position of dialer input box
  975.  *  y                       [IN]        Start y position of dialer input box
  976.  *  width                   [IN]        Width of dilaer input box
  977.  *  height                  [IN]        Height of dialer input box
  978.  *  buffer                  [IN]        Text buffer of dialer input box
  979.  *  buffer_size             [IN]        Buffer size
  980.  *  category_screen_ID      [IN]        Category screen iD
  981.  *  RSK_label               [IN]        RSK label
  982.  *  RSK_icon                [IN]        RSK icon
  983.  *  history_buffer          [IN]        History buffer
  984.  *  flags                   [IN]        
  985.  * RETURNS
  986.  *  void
  987.  *****************************************************************************/
  988. void wgui_setup_dialer_inputbox(
  989.         S32 x,
  990.         S32 y,
  991.         S32 width,
  992.         S32 height,
  993.         U8 *buffer,
  994.         S32 buffer_size,
  995.         U16 category_screen_ID,
  996.         UI_string_type RSK_label,
  997.         PU8 RSK_icon,
  998.         U8 *history_buffer,
  999.         U32 flags)
  1000. {
  1001.     /*----------------------------------------------------------------*/
  1002.     /* Local Variables                                                */
  1003.     /*----------------------------------------------------------------*/
  1004.     S32 l;
  1006.     /*----------------------------------------------------------------*/
  1007.     /* Code Body                                                      */
  1008.     /*----------------------------------------------------------------*/
  1009.     UI_UNUSED_PARAMETER(flags);
  1010. #ifndef __MMI_MULTITAP_KEY_0__
  1011.     gui_create_multitap_input(
  1012.         &wgui_dialer_box_star_key_handler,
  1013.         0,
  1014.         0,
  1015.         0,
  1016.         0,
  1017.         (UI_string_type) wgui_dialer_box_star_key_string);
  1018.     gui_set_multitap_input_callbacks(
  1019.         &wgui_dialer_box_star_key_handler,
  1020.         dialer_inputbox_multitap_input,
  1021.         dialer_inputbox_multitap_input_complete);
  1022. #endif /* __MMI_MULTITAP_KEY_0__ */ 
  1023. #if(ENABLE_DIALER_ZERO_KEY_MULTITAP)
  1024.     gui_create_multitap_input(
  1025.         &wgui_dialer_box_zero_key_handler,
  1026.         0,
  1027.         0,
  1028.         0,
  1029.         0,
  1030.         (UI_string_type) wgui_dialer_box_zero_key_string);
  1031.     gui_set_multitap_input_callbacks(
  1032.         &wgui_dialer_box_zero_key_handler,
  1033.         dialer_inputbox_multitap_input,
  1034.         dialer_inputbox_multitap_input_complete);
  1035. #endif /* (ENABLE_DIALER_ZERO_KEY_MULTITAP) */ 
  1036.     l = gui_strlen((UI_string_type) buffer);
  1037.     create_dialer_inputbox_set_buffer((UI_string_type) buffer, buffer_size, l, l);
  1038.     MMI_dialer_inputbox.text_font = &wgui_dialer_box_f2;
  1039.     MMI_dialer_inputbox.flags |= UI_DIALER_INPUT_BOX_CHARACTER_QUEUE;
  1040. #if(ENABLE_DIALER_PLUS_CHARACTER_HANDLING)
  1041.     MMI_dialer_inputbox.flags |= UI_DIALER_INPUT_BOX_PLUS_CHARACTER_HANDLING;
  1042. #endif 
  1043.     register_dialer_inputbox_keys();
  1044.     move_dialer_inputbox(x, y);
  1045.     resize_dialer_inputbox(width, height);
  1047.     MMI_dialer_inputbox.text_font = (&wgui_dialer_box_f1);
  1048.     MMI_dialer_inputbox.change_callback = dialer_input_box_change_callback;
  1049.     set_dialer_inputbox_mask(0);
  1050.     register_dialer_inputbox_dialer_keys();
  1051.     /* This is done to choose the right font size, if the buffer contains valid data */
  1052.     dialer_input_box_change_callback();
  1053.     dialer_input_box_change_callback();
  1054.     MMI_current_input_mode = INPUT_MODE_123;
  1056.     register_dialer_inputbox_input_callback(wgui_handle_dialer_inputbox_input);
  1057.     /* Leo start 20050805, add dialer inputbox history */
  1058.     set_dialer_inputbox_category_history(category_screen_ID, history_buffer);
  1059.     /* Leo end 20050805 */
  1060.     wgui_dialer_inputbox_RSK_label_icon = RSK_icon;
  1061.     wgui_dialer_inputbox_RSK_label_string = RSK_label;
  1062. #if defined(__MMI_WITH_C_KEY__)
  1063.     SetKeyHandler(wgui_handle_dialer_inputbox_right_softkey_long_press, KEY_CLEAR, KEY_LONG_PRESS);
  1064.     set_right_softkey_function(wgui_handle_dialer_inputbox_right_softkey_up, KEY_EVENT_UP);
  1065. #else /* defined(__MMI_WITH_C_KEY__) */ 
  1066.     set_right_softkey_function(wgui_handle_dialer_inputbox_right_softkey_long_press, KEY_LONG_PRESS);
  1067. #endif /* defined(__MMI_WITH_C_KEY__) */ 
  1068.     wgui_handle_dialer_inputbox_input();
  1069.     if (gui_dialer_input_box_get_text_length(&MMI_dialer_inputbox) <= 0)
  1070.     {
  1071.     #if defined(__MMI_WITH_C_KEY__)
  1072.         SetKeyHandler(wgui_handle_dialer_inputbox_right_softkey_up, KEY_CLEAR, KEY_EVENT_UP);
  1073.         if (wgui_inputbox_empty_callback != NULL)
  1074.         {
  1075.             wgui_inputbox_empty_callback();
  1076.         }
  1077.     #else /* defined(__MMI_WITH_C_KEY__) */ 
  1078.         set_right_softkey_function(wgui_handle_dialer_inputbox_right_softkey_up, KEY_EVENT_UP);
  1079.         if (wgui_inputbox_empty_callback != NULL)
  1080.         {
  1081.             wgui_inputbox_empty_callback();
  1082.         }
  1083.     #endif /* defined(__MMI_WITH_C_KEY__) */ 
  1084.     }
  1085.     else if (wgui_inputbox_not_empty_callback != NULL)
  1086.     {
  1087.         wgui_inputbox_not_empty_callback();
  1088.     }
  1089.     MMI_dialer_inputbox.validation_callback = wgui_dialer_validation_callback;
  1090.     MMI_dialer_inputbox.validation_callback(
  1091.                             MMI_dialer_inputbox.text,
  1092.                             MMI_dialer_inputbox.current_text_p,
  1093.                             (MMI_dialer_inputbox.text_length >> 1) - 1);
  1094. #if defined(__MMI_TOUCH_SCREEN__)
  1095.     SetLeftSoftkeyAlwaysKeyUpByPen();
  1096.     SetRightSoftkeyAlwaysKeyUpByPen();
  1097.     #ifdef __MMI_WGUI_CSK_ENABLE__
  1098.         SetCenterSoftkeyAlwaysKeyUpByPen();
  1099.     #endif 
  1100. #endif /* defined(__MMI_TOUCH_SCREEN__) */ 
  1101. }
  1104. /*****************************************************************************
  1105.  * FUNCTION
  1106.  *  close_dialer_inputbox
  1107.  * DESCRIPTION
  1108.  *  close dialer input box
  1109.  * PARAMETERS
  1110.  *  void
  1111.  * RETURNS
  1112.  *  void
  1113.  *****************************************************************************/
  1114. void close_dialer_inputbox(void)
  1115. {
  1116.     /*----------------------------------------------------------------*/
  1117.     /* Local Variables                                                */
  1118.     /*----------------------------------------------------------------*/
  1120.     /*----------------------------------------------------------------*/
  1121.     /* Code Body                                                      */
  1122.     /*----------------------------------------------------------------*/
  1123.     wgui_inputbox_not_empty_callback = NULL;
  1124.     wgui_inputbox_empty_callback = NULL;
  1125.     wgui_inputbox_validation_callback = NULL;
  1126.     wgui_dialer_inputbox_RSK_function = NULL;
  1127.     wgui_dialer_inputbox_RSK_label_clear = 0;
  1128.     reset_dialer_inputbox();
  1129. #ifndef __MMI_MULTITAP_KEY_0__
  1130.     gui_cancel_timer(dialer_inputbox_complete_multitap_star_key);
  1131. #endif 
  1132. }
  1134. /* Multitap handling for phone number input mode   */
  1136. #define WGUI_INPUTBOX_MULTITAP_NONE          0
  1137. #define WGUI_INPUTBOX_EDIT_MULTITAP_STAR     1
  1138. #define WGUI_INPUTBOX_EDIT_MULTITAP_ANY         2
  1139. #define WGUI_INPUTBOX_EDIT_MULTITAP_ZERO     3
  1141. U8 wgui_inputbox_active_multitap = WGUI_INPUTBOX_MULTITAP_NONE;
  1143. UI_character_type wgui_inputbox_phone_number_star_key_string_for_SIM_number[] = { '*', '+', '' };
  1144. UI_character_type wgui_inputbox_phone_number_zero_key_string_for_SIM_number[] = { '+', '' };
  1146. UI_character_type wgui_inputbox_phone_number_star_key_string[] = { '*', '+', 'p', 'w', '' };
  1147. multitap_input wgui_inputbox_multitap_star_key;
  1149. UI_character_type wgui_inputbox_phone_number_zero_key_string[] = { '+', 'p', 'w', '' };
  1150. multitap_input wgui_inputbox_multitap_zero_key;
  1152. /* flag used to check if english input mpde is on /off */
  1153. U8 MMI_english_input_mode_flag = 0;
  1155. /* byte    MMI_allow_only_english_input_modes=0; */
  1156. /* flag used to store current input mode */
  1157. U8 MMI_current_input_mode = INPUT_MODE_MULTITAP_UPPERCASE_ABC;
  1159. /* used to store current input type */
  1160. S16 MMI_current_input_type = 0;
  1162. /* MTK Terry for 0x81 encoding support for Phone Book */
  1163. S16 MMI_current_input_ext_type = 0;
  1165. pBOOL flag_use_current_input_type = FALSE;
  1167. //MTK Elvis it is not used, so remove it
  1168. //S16           MMI_saved_input_type=0;
  1169. //MTK end
  1171. /* MTK Elvis for prefered input method */
  1172. #if defined(__MMI_PREFER_INPUT_METHOD__)
  1173. S16 MMI_prefered_input_type = INPUT_TYPE_TR_BOPOMO;
  1174. #endif 
  1175. /* MTK end */
  1176. /*----------------------------------------------------------------------------
  1177. Function:         inputbox_change_mode
  1178. Description:      a function pointer store the address of function whcih handle
  1179.                input box change mode
  1181. Input parameters :   none
  1182. Output Parameters:   none
  1183. Returns:       none
  1184. ----------------------------------------------------------------------------*/
  1185. void (*inputbox_change_mode) (void);
  1188. /*****************************************************************************
  1189.  * FUNCTION
  1190.  *  set_MMI_current_input_type
  1191.  * DESCRIPTION
  1192.  *  set mmi current input mode
  1193.  * PARAMETERS
  1194.  *  void
  1195.  * RETURNS
  1196.  *  void
  1197.  *****************************************************************************/
  1198. /* MTK Elvis modify for stacked character---thai */
  1199. void set_MMI_current_input_type(void)
  1200. {
  1201.     /*----------------------------------------------------------------*/
  1202.     /* Local Variables                                                */
  1203.     /*----------------------------------------------------------------*/
  1205.     /*----------------------------------------------------------------*/
  1206.     /* Code Body                                                      */
  1207.     /*----------------------------------------------------------------*/
  1208.     switch (MMI_current_input_mode)
  1209.     {
  1210.         case INPUT_MODE_MULTITAP_UPPERCASE_ABC:
  1211.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE;
  1212.             break;
  1213.         case INPUT_MODE_MULTITAP_LOWERCASE_ABC:
  1214.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE;
  1215.             break;
  1216.         case INPUT_MODE_123:
  1217.             MMI_current_input_type = INPUT_TYPE_NUMERIC_CHANGEABLE;
  1218.             break;
  1219.     #if defined(__MMI_WCSS_INPUT_FORMAT_SUPPORT__)
  1220.         case INPUT_MODE_MULTITAP_UPPERCASE_ABC_NO_NUMERIC:
  1221.             MMI_current_input_type = INPUT_TYPE_ALPHABATIC_UPPERCASE;
  1222.             break;
  1223.         case INPUT_MODE_MULTITAP_LOWERCASE_ABC_NO_NUMERIC:
  1224.             MMI_current_input_type = INPUT_TYPE_ALPHABATIC_LOWERCASE;
  1225.             break;
  1226.         case INPUT_MODE_123_SYMBOLS:
  1227.             MMI_current_input_type = INPUT_TYPE_NUMERIC_SYMBOL;
  1228.             break;
  1229.     #endif /* defined(__MMI_WCSS_INPUT_FORMAT_SUPPORT__) */ 
  1230.     #if defined(__MMI_MULTITAP_THAI__)
  1231.         case INPUT_MODE_MULTITAP_THAI:
  1232.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_MULTITAP_THAI;
  1233.             break;
  1234.     #endif /* defined(__MMI_MULTITAP_THAI__) */ 
  1236.     #if defined(__MMI_MULTITAP_SPANISH__)
  1237.         case INPUT_MODE_MULTITAP_UPPERCASE_SPANISH:
  1238.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_SPANISH;
  1239.             break;
  1240.         case INPUT_MODE_MULTITAP_LOWERCASE_SPANISH:
  1241.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_SPANISH;
  1242.             break;
  1243.     #endif /* defined(__MMI_MULTITAP_SPANISH__) */ 
  1244.     #if defined(__MMI_MULTITAP_DANISH__)
  1245.         case INPUT_MODE_MULTITAP_UPPERCASE_DANISH:
  1246.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_DANISH;
  1247.             break;
  1248.         case INPUT_MODE_MULTITAP_LOWERCASE_DANISH:
  1249.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_DANISH;
  1250.             break;
  1251.     #endif /* defined(__MMI_MULTITAP_DANISH__) */ 
  1252.     #if defined(__MMI_MULTITAP_POLISH__)
  1253.         case INPUT_MODE_MULTITAP_UPPERCASE_POLISH:
  1254.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_POLISH;
  1255.             break;
  1256.         case INPUT_MODE_MULTITAP_LOWERCASE_POLISH:
  1257.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_POLISH;
  1258.             break;
  1259.     #endif /* defined(__MMI_MULTITAP_POLISH__) */ 
  1260.     #if defined(__MMI_MULTITAP_FRENCH__)
  1261.         case INPUT_MODE_MULTITAP_UPPERCASE_FRENCH:
  1262.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_FRENCH;
  1263.             break;
  1264.         case INPUT_MODE_MULTITAP_LOWERCASE_FRENCH:
  1265.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_FRENCH;
  1266.             break;
  1267.     #endif /* defined(__MMI_MULTITAP_FRENCH__) */ 
  1268.     #if defined(__MMI_MULTITAP_GERMAN__)
  1269.         case INPUT_MODE_MULTITAP_UPPERCASE_GERMAN:
  1270.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_GERMAN;
  1271.             break;
  1272.         case INPUT_MODE_MULTITAP_LOWERCASE_GERMAN:
  1273.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_GERMAN;
  1274.             break;
  1275.     #endif /* defined(__MMI_MULTITAP_GERMAN__) */ 
  1276.     #if defined(__MMI_MULTITAP_ITALIAN__)
  1277.         case INPUT_MODE_MULTITAP_UPPERCASE_ITALIAN:
  1278.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_ITALIAN;
  1279.             break;
  1280.         case INPUT_MODE_MULTITAP_LOWERCASE_ITALIAN:
  1281.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_ITALIAN;
  1282.             break;
  1283.     #endif /* defined(__MMI_MULTITAP_ITALIAN__) */ 
  1284.     #if defined(__MMI_MULTITAP_RUSSIAN__)
  1285.         case INPUT_MODE_MULTITAP_UPPERCASE_RUSSIAN:
  1286.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_RUSSIAN;
  1287.             break;
  1288.         case INPUT_MODE_MULTITAP_LOWERCASE_RUSSIAN:
  1289.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_RUSSIAN;
  1290.             break;
  1291.     #endif /* defined(__MMI_MULTITAP_RUSSIAN__) */ 
  1292.     #if defined(__MMI_MULTITAP_BULGARIAN__)
  1293.         case INPUT_MODE_MULTITAP_UPPERCASE_BULGARIAN:
  1294.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_BULGARIAN;
  1295.             break;
  1296.         case INPUT_MODE_MULTITAP_LOWERCASE_BULGARIAN:
  1297.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_BULGARIAN;
  1298.             break;
  1299.     #endif /* defined(__MMI_MULTITAP_BULGARIAN__) */ 
  1300.     #if defined(__MMI_MULTITAP_TURKISH__)
  1301.         case INPUT_MODE_MULTITAP_UPPERCASE_TURKISH:
  1302.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_TURKISH;
  1303.             break;
  1304.         case INPUT_MODE_MULTITAP_LOWERCASE_TURKISH:
  1305.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_TURKISH;
  1306.             break;
  1307.     #endif /* defined(__MMI_MULTITAP_TURKISH__) */ 
  1308.     #if defined(__MMI_MULTITAP_PORTUGUESE__)
  1309.         case INPUT_MODE_MULTITAP_UPPERCASE_PORTUGUESE:
  1310.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_PORTUGUESE;
  1311.             break;
  1312.         case INPUT_MODE_MULTITAP_LOWERCASE_PORTUGUESE:
  1313.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_PORTUGUESE;
  1314.             break;
  1315.     #endif /* defined(__MMI_MULTITAP_PORTUGUESE__) */ 
  1316.     #if defined(__MMI_MULTITAP_HINDI__)
  1317.         case INPUT_MODE_MULTITAP_HINDI:
  1318.             MMI_current_input_type = INPUT_TYPE_MULTITAP_HINDI;
  1319.             break;
  1320.     #endif /* defined(__MMI_MULTITAP_HINDI__) */ 
  1321.             /* PMT RAKESH START 20061006 */
  1322.     #if defined(__MMI_MULTITAP_MARATHI__)
  1323.         case INPUT_MODE_MULTITAP_MARATHI:
  1324.             MMI_current_input_type = INPUT_TYPE_MULTITAP_MARATHI;
  1325.             break;
  1326.     #endif /* defined(__MMI_MULTITAP_MARATHI__) */ 
  1327.             /* PMT RAKESH END 20061006 */
  1328.     #if defined(__MMI_MULTITAP_INDONESIAN__)
  1329.         case INPUT_MODE_MULTITAP_UPPERCASE_INDONESIAN:
  1330.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_INDONESIAN;
  1331.             break;
  1332.         case INPUT_MODE_MULTITAP_LOWERCASE_INDONESIAN:
  1333.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_INDONESIAN;
  1334.             break;
  1335.     #endif /* defined(__MMI_MULTITAP_INDONESIAN__) */ 
  1336.     #if defined(__MMI_MULTITAP_CZECH__)
  1337.         case INPUT_MODE_MULTITAP_UPPERCASE_CZECH:
  1338.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_CZECH;
  1339.             break;
  1340.         case INPUT_MODE_MULTITAP_LOWERCASE_CZECH:
  1341.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_CZECH;
  1342.             break;
  1343.     #endif /* defined(__MMI_MULTITAP_CZECH__) */ 
  1344.     #if defined(__MMI_MULTITAP_MALAY__)
  1345.         case INPUT_MODE_MULTITAP_UPPERCASE_MALAY:
  1346.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_MALAY;
  1347.             break;
  1348.         case INPUT_MODE_MULTITAP_LOWERCASE_MALAY:
  1349.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_MALAY;
  1350.             break;
  1351.     #endif /* defined(__MMI_MULTITAP_MALAY__) */ 
  1352.     #if defined(__MMI_MULTITAP_VIETNAMESE__)
  1353.         case INPUT_MODE_MULTITAP_UPPERCASE_VIETNAMESE:
  1354.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_VIETNAMESE;
  1355.             break;
  1356.         case INPUT_MODE_MULTITAP_LOWERCASE_VIETNAMESE:
  1357.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_VIETNAMESE;
  1358.             break;
  1359.     #endif /* defined(__MMI_MULTITAP_VIETNAMESE__) */ 
  1360.     #if defined(__MMI_MULTITAP_FINNISH__)
  1361.         case INPUT_MODE_MULTITAP_UPPERCASE_FINNISH:
  1362.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_FINNISH;
  1363.             break;
  1364.         case INPUT_MODE_MULTITAP_LOWERCASE_FINNISH:
  1365.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_FINNISH;
  1366.             break;
  1367.     #endif /* defined(__MMI_MULTITAP_FINNISH__) */ 
  1368.     #if defined(__MMI_MULTITAP_HUNGARIAN__)
  1369.         case INPUT_MODE_MULTITAP_UPPERCASE_HUNGARIAN:
  1370.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_HUNGARIAN;
  1371.             break;
  1372.         case INPUT_MODE_MULTITAP_LOWERCASE_HUNGARIAN:
  1373.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_HUNGARIAN;
  1374.             break;
  1375.     #endif /* defined(__MMI_MULTITAP_HUNGARIAN__) */ 
  1376.     #if defined(__MMI_MULTITAP_HEBREW__)
  1377.         case INPUT_MODE_MULTITAP_HEBREW:
  1378.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_HEBREW;
  1379.             break;
  1380.     #endif /* defined(__MMI_MULTITAP_HEBREW__) */ 
  1381.     #if defined(__MMI_MULTITAP_SLOVAK__)
  1382.         case INPUT_MODE_MULTITAP_UPPERCASE_SLOVAK:
  1383.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_SLOVAK;
  1384.             break;
  1385.         case INPUT_MODE_MULTITAP_LOWERCASE_SLOVAK:
  1386.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_SLOVAK;
  1387.             break;
  1388.     #endif /* defined(__MMI_MULTITAP_SLOVAK__) */ 
  1389.     #if defined(__MMI_MULTITAP_DUTCH__)
  1390.         case INPUT_MODE_MULTITAP_UPPERCASE_DUTCH:
  1391.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_DUTCH;
  1392.             break;
  1393.         case INPUT_MODE_MULTITAP_LOWERCASE_DUTCH:
  1394.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_DUTCH;
  1395.             break;
  1396.     #endif /* defined(__MMI_MULTITAP_DUTCH__) */ 
  1398.     #if defined(__MMI_MULTITAP_ARABIC__)
  1399.         case INPUT_MODE_MULTITAP_ARABIC:
  1400.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_ARABIC;
  1401.             break;
  1402.     #endif /* defined(__MMI_MULTITAP_ARABIC__) */ 
  1403. //PMT START PERSIAN
  1404. #if defined(__MMI_MULTITAP_PERSIAN__)
  1405. case INPUT_MODE_MULTITAP_PERSIAN:
  1406. MMI_current_input_type=INPUT_TYPE_ALPHANUMERIC_PERSIAN;
  1407. break;
  1408. #endif
  1409. //PMT END PERSIAN
  1410.     #if defined(__MMI_MULTITAP_NORWEGIAN__)
  1411.         case INPUT_MODE_MULTITAP_UPPERCASE_NORWEGIAN:
  1412.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_NORWEGIAN;
  1413.             break;
  1414.         case INPUT_MODE_MULTITAP_LOWERCASE_NORWEGIAN:
  1415.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_NORWEGIAN;
  1416.             break;
  1417.     #endif /* defined(__MMI_MULTITAP_NORWEGIAN__) */ 
  1418.     #if defined(__MMI_MULTITAP_SWEDISH__)
  1419.         case INPUT_MODE_MULTITAP_UPPERCASE_SWEDISH:
  1420.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_SWEDISH;
  1421.             break;
  1422.         case INPUT_MODE_MULTITAP_LOWERCASE_SWEDISH:
  1423.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_SWEDISH;
  1424.             break;
  1425.     #endif /* defined(__MMI_MULTITAP_SWEDISH__) */ 
  1426.     #if defined(__MMI_MULTITAP_CROATIAN__)
  1427.         case INPUT_MODE_MULTITAP_UPPERCASE_CROATIAN:
  1428.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_CROATIAN;
  1429.             break;
  1430.         case INPUT_MODE_MULTITAP_LOWERCASE_CROATIAN:
  1431.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_CROATIAN;
  1432.             break;
  1433.     #endif /* defined(__MMI_MULTITAP_CROATIAN__) */ 
  1434.     #if defined(__MMI_MULTITAP_ROMANIAN__)
  1435.         case INPUT_MODE_MULTITAP_UPPERCASE_ROMANIAN:
  1436.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_ROMANIAN;
  1437.             break;
  1438.         case INPUT_MODE_MULTITAP_LOWERCASE_ROMANIAN:
  1439.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_ROMANIAN;
  1440.             break;
  1441.     #endif /* defined(__MMI_MULTITAP_ROMANIAN__) */ 
  1442.     #if defined(__MMI_MULTITAP_SLOVENIAN__)
  1443.         case INPUT_MODE_MULTITAP_UPPERCASE_SLOVENIAN:
  1444.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_SLOVENIAN;
  1445.             break;
  1446.         case INPUT_MODE_MULTITAP_LOWERCASE_SLOVENIAN:
  1447.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_SLOVENIAN;
  1448.             break;
  1449.     #endif /* defined(__MMI_MULTITAP_SLOVENIAN__) */ 
  1450.     #if defined(__MMI_MULTITAP_GREEK__)
  1451.         case INPUT_MODE_MULTITAP_UPPERCASE_GREEK:
  1452.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_UPPERCASE_GREEK;
  1453.             break;
  1454.         case INPUT_MODE_MULTITAP_LOWERCASE_GREEK:
  1455.             MMI_current_input_type = INPUT_TYPE_ALPHANUMERIC_LOWERCASE_GREEK;
  1456.             break;
  1457.     #endif /* defined(__MMI_MULTITAP_GREEK__) */ 
  1458.     #if defined(__MMI_T9__) || defined(__MMI_ZI__) || defined(__MMI_KA__) || defined(__MMI_ITAP__)|| defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  1459. //KP Jerry modify on 2007-4-18 start
  1460. #ifdef __MMI_LANG_TR_CHINESE__      //KP Jerry add on 2007-4-17
  1461.         case INPUT_MODE_TR_MULTITAP_BOPOMO:
  1462.             MMI_current_input_type = INPUT_TYPE_TR_MULTITAP_BOPOMO;
  1463.             break;
  1465.         case INPUT_MODE_TR_BOPOMO:
  1466.             MMI_current_input_type = INPUT_TYPE_TR_BOPOMO;
  1467.             break;
  1469.         case INPUT_MODE_TR_STROKE:
  1470.             MMI_current_input_type = INPUT_TYPE_TR_STROKE;
  1471.             break;
  1472. #endif/*__MMI_LANG_TR_CHINESE__*/      //KP Jerry add on 2007-4-17
  1474. #ifdef __MMI_LANG_SM_CHINESE__      //KP Jerry add on 2007-4-17
  1475.         case INPUT_MODE_SM_MULTITAP_PINYIN:
  1476.             MMI_current_input_type = INPUT_TYPE_SM_MULTITAP_PINYIN;
  1477.             break;
  1479.         case INPUT_MODE_SM_PINYIN:
  1480.             MMI_current_input_type = INPUT_TYPE_SM_PINYIN;
  1481.             break;
  1483.         case INPUT_MODE_SM_STROKE:
  1484.             MMI_current_input_type = INPUT_TYPE_SM_STROKE;
  1485.             break;
  1486. #endif/*__MMI_LANG_SM_CHINESE__*/      //KP Jerry add on 2007-4-17
  1487. //KP Jerry modify on 2007-4-18 end
  1489.         case INPUT_MODE_SMART_UPPERCASE_ABC:
  1490.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_ABC;
  1491.             break;
  1493.         case INPUT_MODE_SMART_LOWERCASE_ABC:
  1494.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_ABC;
  1495.             break;
  1497. #ifdef __MMI_LANG_THAI__      //KP Jerry add on 2007-4-17
  1498.         case INPUT_MODE_SMART_THAI:
  1499.             MMI_current_input_type = INPUT_TYPE_SMART_THAI;
  1500.             break;
  1501. #endif     //KP Jerry add on 2007-4-17
  1503.             /* MTK Elvis for R2L characters */
  1504. #ifdef __MMI_LANG_ARABIC__      //KP Jerry add on 2007-4-17
  1505.         case INPUT_MODE_SMART_ARABIC:
  1506.             MMI_current_input_type = INPUT_TYPE_SMART_ARABIC;
  1507.             break;
  1508. #endif     //KP Jerry add on 2007-4-17
  1509. //PMT START PERSIAN
  1510. #ifdef __MMI_LANG_PERSIAN__      //KP Jerry add on 2007-4-17
  1511. case INPUT_MODE_SMART_PERSIAN:
  1512.             MMI_current_input_type = INPUT_TYPE_SMART_PERSIAN;
  1513.             break;
  1514. #endif     //KP Jerry add on 2007-4-17
  1515. //PMT END PERSIAN
  1516. #ifdef __MMI_LANG_HINDI__      //KP Jerry add on 2007-4-17
  1517.         case INPUT_MODE_SMART_HINDI:
  1518.             MMI_current_input_type = INPUT_TYPE_SMART_HINDI;
  1519.             break;
  1520. #endif     //KP Jerry add on 2007-4-17
  1521. #ifdef __MMI_LANG_HEBREW__      //KP Jerry add on 2007-4-17
  1522.         case INPUT_MODE_SMART_HEBREW:
  1523.             MMI_current_input_type = INPUT_TYPE_SMART_HEBREW;
  1524.             break;
  1525. #endif     //KP Jerry add on 2007-4-17
  1526.     #if defined(__MMI_T9_SPANISH__) || defined(__MMI_ZI_EU_SPANISH__) || defined(__MMI_ZI_SA_SPANISH__) || defined(__MMI_CSTAR_SPANISH__)    //KP Jerry add "__MMI_CSTAR_SPANISH__" on 2007-4-6
  1527.         case INPUT_MODE_SMART_UPPERCASE_SPANISH:
  1528.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_SPANISH;
  1529.             break;
  1530.         case INPUT_MODE_SMART_LOWERCASE_SPANISH:
  1531.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_SPANISH;
  1532.             break;
  1533.     #endif /* defined(__MMI_T9_SPANISH__) || defined(__MMI_ZI_EU_SPANISH__) || defined(__MMI_ZI_SA_SPANISH__) || defined(__MMI_CSTAR_SPANISH__) */     //KP Jerry add "__MMI_CSTAR_SPANISH__" on 2007-4-6
  1534.     #if defined(__MMI_T9_DANISH__) || defined(__MMI_ZI_DANISH__) || defined(__MMI_CSTAR_DANISH__) //KP Jerry add "__MMI_CSTAR_DANISH__" on 2007-4-6
  1535.         case INPUT_MODE_SMART_UPPERCASE_DANISH:
  1536.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_DANISH;
  1537.             break;
  1538.         case INPUT_MODE_SMART_LOWERCASE_DANISH:
  1539.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_DANISH;
  1540.             break;
  1541.     #endif /* defined(__MMI_T9_DANISH__) || defined(__MMI_ZI_DANISH__) || defined(__MMI_CSTAR_DANISH__) */  //KP Jerry add "__MMI_CSTAR_DANISH__" on 2007-4-6
  1542.     #if defined(__MMI_T9_POLISH__) || defined(__MMI_ZI_POLISH__) || defined(__MMI_CSTAR_POLISH__) //KP Jerry add "__MMI_CSTAR_POLISH__" on 2007-4-6
  1543.         case INPUT_MODE_SMART_UPPERCASE_POLISH:
  1544.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_POLISH;
  1545.             break;
  1546.         case INPUT_MODE_SMART_LOWERCASE_POLISH:
  1547.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_POLISH;
  1548.             break;
  1549.     #endif /* defined(__MMI_T9_POLISH__) || defined(__MMI_ZI_POLISH__) || defined(__MMI_CSTAR_POLISH__) */  //KP Jerry add "__MMI_CSTAR_POLISH__" on 2007-4-6
  1550.     #if defined(__MMI_T9_FRENCH__) || defined(__MMI_ZI_CA_FRENCH__) || defined(__MMI_ZI_EU_FRENCH__) || defined(__MMI_CSTAR_FRENCH__) //KP Jerry add "__MMI_CSTAR_FRENCH__" on 2007-4-6
  1551.         case INPUT_MODE_SMART_UPPERCASE_FRENCH:
  1552.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_FRENCH;
  1553.             break;
  1554.         case INPUT_MODE_SMART_LOWERCASE_FRENCH:
  1555.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_FRENCH;
  1556.             break;
  1557.     #endif /* defined(__MMI_T9_FRENCH__) || defined(__MMI_ZI_CA_FRENCH__) || defined(__MMI_ZI_EU_FRENCH__) || defined(__MMI_CSTAR_FRENCH__) */  //KP Jerry add "__MMI_CSTAR_FRENCH__" on 2007-4-6
  1558.     #if defined(__MMI_T9_GERMAN__) || defined(__MMI_ZI_GERMAN__) || defined(__MMI_CSTAR_GERMAN__) //KP Jerry add "__MMI_CSTAR_GERMAN__" on 2007-4-6
  1559.         case INPUT_MODE_SMART_UPPERCASE_GERMAN:
  1560.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_GERMAN;
  1561.             break;
  1562.         case INPUT_MODE_SMART_LOWERCASE_GERMAN:
  1563.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_GERMAN;
  1564.             break;
  1565.     #endif /* defined(__MMI_T9_GERMAN__) || defined(__MMI_ZI_GERMAN__) || defined(__MMI_CSTAR_GERMAN__) */  //KP Jerry add "__MMI_CSTAR_GERMAN__" on 2007-4-6
  1566.     #if defined(__MMI_T9_ITALIAN__) || defined(__MMI_ZI_ITALIAN__) || defined(__MMI_CSTAR_ITALIAN__) //KP Jerry add "__MMI_CSTAR_ITALIAN__" on 2007-4-6
  1567.         case INPUT_MODE_SMART_UPPERCASE_ITALIAN:
  1568.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_ITALIAN;
  1569.             break;
  1570.         case INPUT_MODE_SMART_LOWERCASE_ITALIAN:
  1571.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_ITALIAN;
  1572.             break;
  1573.     #endif /* defined(__MMI_T9_ITALIAN__) || defined(__MMI_ZI_ITALIAN__) || defined(__MMI_CSTAR_ITALIAN__) */  //KP Jerry add "__MMI_CSTAR_ITALIAN__" on 2007-4-6
  1574.     #if defined(__MMI_T9_RUSSIAN__) || defined(__MMI_ZI_RUSSIAN__) || defined(__MMI_ZI_RECOMMENDED_SIZE_RUSSIAN__) || defined(__MMI_CSTAR_RUSSIAN__) //KP Jerry add "__MMI_CSTAR_RUSSIAN__" on 2007-4-6
  1575.         case INPUT_MODE_SMART_UPPERCASE_RUSSIAN:
  1576.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_RUSSIAN;
  1577.             break;
  1578.         case INPUT_MODE_SMART_LOWERCASE_RUSSIAN:
  1579.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_RUSSIAN;
  1580.             break;
  1581.     #endif /* defined(__MMI_T9_RUSSIAN__) || defined(__MMI_ZI_RUSSIAN__) || defined(__MMI_ZI_RECOMMENDED_SIZE_RUSSIAN__) || defined(__MMI_CSTAR_RUSSIAN__) */  //KP Jerry add "__MMI_CSTAR_RUSSIAN__" on 2007-4-6
  1582.     #if defined(__MMI_T9_BULGARIAN__) || defined(__MMI_ZI_BULGARIAN__) || defined(__MMI_CSTAR_BULGARIAN__) //KP Jerry add "__MMI_CSTAR_BULGARIAN__" on 2007-4-6
  1583.         case INPUT_MODE_SMART_UPPERCASE_BULGARIAN:
  1584.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_BULGARIAN;
  1585.             break;
  1586.         case INPUT_MODE_SMART_LOWERCASE_BULGARIAN:
  1587.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_BULGARIAN;
  1588.             break;
  1589.     #endif /* defined(__MMI_T9_BULGARIAN__) || defined(__MMI_ZI_BULGARIAN__) || defined(__MMI_CSTAR_BULGARIAN__) */  //KP Jerry add "__MMI_CSTAR_BULGARIAN__" on 2007-4-6
  1590.     #if defined(__MMI_ZI_TURKISH__) || defined(__MMI_T9_TURKISH__) || defined(__MMI_CSTAR_TURKISH__) //KP Jerry add "__MMI_CSTAR_TURKISH__" on 2007-4-6
  1591.         case INPUT_MODE_SMART_UPPERCASE_TURKISH:
  1592.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_TURKISH;
  1593.             break;
  1594.         case INPUT_MODE_SMART_LOWERCASE_TURKISH:
  1595.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_TURKISH;
  1596.             break;
  1597.     #endif /* defined(__MMI_ZI_TURKISH__) || defined(__MMI_T9_TURKISH__) || defined(__MMI_CSTAR_TURKISH__) */  //KP Jerry add "__MMI_CSTAR_TURKISH__" on 2007-4-6
  1598.     #if defined(__MMI_T9_PORTUGUESE__) || defined(__MMI_ZI_EU_PORTUGUESE__) || defined(__MMI_ZI_SA_PORTUGUESE__) || defined(__MMI_ZI_BZ_PORTUGUESE__) || defined(__MMI_CSTAR_PORTUGUESE__) //KP Jerry add "__MMI_CSTAR_PORTUGUESE__" on 2007-4-6
  1599.         case INPUT_MODE_SMART_UPPERCASE_PORTUGUESE:
  1600.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_PORTUGUESE;
  1601.             break;
  1602.         case INPUT_MODE_SMART_LOWERCASE_PORTUGUESE:
  1603.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_PORTUGUESE;
  1604.             break;
  1605.     #endif /* defined(__MMI_T9_PORTUGUESE__) || defined(__MMI_ZI_EU_PORTUGUESE__) || defined(__MMI_ZI_SA_PORTUGUESE__) || defined(__MMI_ZI_BZ_PORTUGUESE__) || defined(__MMI_CSTAR_PORTUGUESE__) */  //KP Jerry add "__MMI_CSTAR_PORTUGUESE__" on 2007-4-6
  1606.     #if defined(__MMI_ZI_INDONESIAN__) || defined(__MMI_T9_INDONESIAN__) || defined(__MMI_CSTAR_INDONESIAN__) //KP Jerry add "__MMI_CSTAR_INDONESIAN__" on 2007-4-6
  1607.         case INPUT_MODE_SMART_UPPERCASE_INDONESIAN:
  1608.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_INDONESIAN;
  1609.             break;
  1610.         case INPUT_MODE_SMART_LOWERCASE_INDONESIAN:
  1611.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_INDONESIAN;
  1612.             break;
  1613.     #endif /* defined(__MMI_ZI_INDONESIAN__) || defined(__MMI_T9_INDONESIAN__) || defined(__MMI_CSTAR_INDONESIAN__) */  //KP Jerry add "__MMI_CSTAR_INDONESIAN__" on 2007-4-6
  1614.     #if defined(__MMI_ZI_CZECH__) || defined(__MMI_T9_CZECH__) || defined(__MMI_CSTAR_CZECH__) //KP Jerry add "__MMI_CSTAR_CZECH__" on 2007-4-6
  1615.         case INPUT_MODE_SMART_UPPERCASE_CZECH:
  1616.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_CZECH;
  1617.             break;
  1618.         case INPUT_MODE_SMART_LOWERCASE_CZECH:
  1619.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_CZECH;
  1620.             break;
  1621.     #endif /* defined(__MMI_ZI_CZECH__) || defined(__MMI_T9_CZECH__) || defined(__MMI_CSTAR_CZECH__) */  //KP Jerry add "__MMI_CSTAR_CZECH__" on 2007-4-6
  1622.     #if defined(__MMI_ZI_MALAY__) || defined(__MMI_T9_MALAY__) || defined(__MMI_CSTAR_MALAY__) //KP Jerry add "__MMI_CSTAR_MALAY__" on 2007-4-6
  1623.         case INPUT_MODE_SMART_UPPERCASE_MALAY:
  1624.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_MALAY;
  1625.             break;
  1626.         case INPUT_MODE_SMART_LOWERCASE_MALAY:
  1627.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_MALAY;
  1628.             break;
  1629.     #endif /* defined(__MMI_ZI_MALAY__) || defined(__MMI_T9_MALAY__) || defined(__MMI_CSTAR_MALAY__) */  //KP Jerry add "__MMI_CSTAR_MALAY__" on 2007-4-6
  1630.     #if defined(__MMI_ZI_VIETNAMESE__) || defined(__MMI_T9_VIETNAMESE__) || defined(__MMI_CSTAR_VIETNAMESE__) //KP Jerry add "__MMI_CSTAR_VIETNAMESE__" on 2007-4-6
  1631.         case INPUT_MODE_SMART_UPPERCASE_VIETNAMESE:
  1632.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_VIETNAMESE;
  1633.             break;
  1634.         case INPUT_MODE_SMART_LOWERCASE_VIETNAMESE:
  1635.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_VIETNAMESE;
  1636.             break;
  1637.     #endif /* defined(__MMI_ZI_VIETNAMESE__) || defined(__MMI_T9_VIETNAMESE__) || defined(__MMI_CSTAR_VIETNAMESE__) */  //KP Jerry add "__MMI_CSTAR_VIETNAMESE__" on 2007-4-6
  1638.     #if defined(__MMI_T9_FINNISH__) || defined(__MMI_ZI_FINNISH__) || defined(__MMI_CSTAR_FINNISH__) //KP Jerry add "__MMI_CSTAR_FINNISH__" on 2007-4-6
  1639.         case INPUT_MODE_SMART_UPPERCASE_FINNISH:
  1640.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_FINNISH;
  1641.             break;
  1642.         case INPUT_MODE_SMART_LOWERCASE_FINNISH:
  1643.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_FINNISH;
  1644.             break;
  1645.     #endif /* defined(__MMI_T9_FINNISH__) || defined(__MMI_ZI_FINNISH__) || defined(__MMI_CSTAR_FINNISH__) */  //KP Jerry add "__MMI_CSTAR_FINNISH__" on 2007-4-6
  1646.     #if defined(__MMI_ZI_HUNGARIAN__) || defined(__MMI_T9_HUNGARIAN__) || defined(__MMI_CSTAR_HUNGARIAN__) //KP Jerry add "__MMI_CSTAR_HUNGARIAN__" on 2007-4-6
  1647.         case INPUT_MODE_SMART_UPPERCASE_HUNGARIAN:
  1648.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_HUNGARIAN;
  1649.             break;
  1650.         case INPUT_MODE_SMART_LOWERCASE_HUNGARIAN:
  1651.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_HUNGARIAN;
  1652.             break;
  1653.     #endif /* defined(__MMI_ZI_HUNGARIAN__) || defined(__MMI_T9_HUNGARIAN__) || defined(__MMI_CSTAR_HUNGARIAN__) */  //KP Jerry add "__MMI_CSTAR_HUNGARIAN__" on 2007-4-6
  1654.     #if defined(__MMI_T9_SLOVAK__) || defined(__MMI_ZI_SLOVAK__) || defined(__MMI_CSTAR_SLOVAK__) //KP Jerry add "__MMI_CSTAR_SLOVAK__" on 2007-4-6
  1655.         case INPUT_MODE_SMART_UPPERCASE_SLOVAK:
  1656.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_SLOVAK;
  1657.             break;
  1658.         case INPUT_MODE_SMART_LOWERCASE_SLOVAK:
  1659.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_SLOVAK;
  1660.             break;
  1661.     #endif /* defined(__MMI_T9_SLOVAK__) || defined(__MMI_ZI_SLOVAK__) || defined(__MMI_CSTAR_SLOVAK__) */  //KP Jerry add "__MMI_CSTAR_SLOVAK__" on 2007-4-6
  1662.     #if defined(__MMI_ZI_DUTCH__) || defined(__MMI_T9_DUTCH__) || defined(__MMI_CSTAR_DUTCH__) //KP Jerry add "__MMI_CSTAR_DUTCH__" on 2007-4-6
  1663.         case INPUT_MODE_SMART_UPPERCASE_DUTCH:
  1664.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_DUTCH;
  1665.             break;
  1666.         case INPUT_MODE_SMART_LOWERCASE_DUTCH:
  1667.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_DUTCH;
  1668.             break;
  1669.     #endif /* defined(__MMI_ZI_DUTCH__) || defined(__MMI_T9_DUTCH__) || defined(__MMI_CSTAR_DUTCH__) */  //KP Jerry add "__MMI_CSTAR_DUTCH__" on 2007-4-6
  1670.     #if defined(__MMI_T9_NORWEGIAN__) || defined(__MMI_ZI_NORWEGIAN__) || defined(__MMI_CSTAR_NORWEGIAN__) //KP Jerry add "__MMI_CSTAR_NORWEGIAN__" on 2007-4-6
  1671.         case INPUT_MODE_SMART_UPPERCASE_NORWEGIAN:
  1672.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_NORWEGIAN;
  1673.             break;
  1674.         case INPUT_MODE_SMART_LOWERCASE_NORWEGIAN:
  1675.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_NORWEGIAN;
  1676.             break;
  1677.     #endif /* defined(__MMI_T9_NORWEGIAN__) || defined(__MMI_ZI_NORWEGIAN__) || defined(__MMI_CSTAR_NORWEGIAN__) */  //KP Jerry add "__MMI_CSTAR_NORWEGIAN__" on 2007-4-6
  1678.     #if defined(__MMI_T9_SWEDISH__) || defined(__MMI_ZI_SWEDISH__) || defined(__MMI_CSTAR_SWEDISH__) //KP Jerry add "__MMI_CSTAR_SWEDISH__" on 2007-4-6
  1679.         case INPUT_MODE_SMART_UPPERCASE_SWEDISH:
  1680.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_SWEDISH;
  1681.             break;
  1682.         case INPUT_MODE_SMART_LOWERCASE_SWEDISH:
  1683.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_SWEDISH;
  1684.             break;
  1685.     #endif /* defined(__MMI_T9_SWEDISH__) || defined(__MMI_ZI_SWEDISH__) || defined(__MMI_CSTAR_SWEDISH__) */  //KP Jerry add "__MMI_CSTAR_SWEDISH__" on 2007-4-6
  1686.     #if defined(__MMI_T9_CROATIAN__) || defined(__MMI_ZI_CROATIAN__) || defined(__MMI_CSTAR_CROATIAN__) //KP Jerry add "__MMI_CSTAR_CROATIAN__" on 2007-4-6
  1687.         case INPUT_MODE_SMART_UPPERCASE_CROATIAN:
  1688.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_CROATIAN;
  1689.             break;
  1690.         case INPUT_MODE_SMART_LOWERCASE_CROATIAN:
  1691.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_CROATIAN;
  1692.             break;
  1693.     #endif /* defined(__MMI_T9_CROATIAN__) || defined(__MMI_ZI_CROATIAN__) || defined(__MMI_CSTAR_CROATIAN__) */  //KP Jerry add "__MMI_CSTAR_CROATIAN__" on 2007-4-6
  1694.     #if defined(__MMI_ZI_ROMANIAN__) || defined(__MMI_T9_ROMANIAN__) || defined(__MMI_CSTAR_ROMANIAN__) //KP Jerry add "__MMI_CSTAR_ROMANIAN__" on 2007-4-6
  1695.         case INPUT_MODE_SMART_UPPERCASE_ROMANIAN:
  1696.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_ROMANIAN;
  1697.             break;
  1698.         case INPUT_MODE_SMART_LOWERCASE_ROMANIAN:
  1699.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_ROMANIAN;
  1700.             break;
  1701.     #endif /* defined(__MMI_ZI_ROMANIAN__) || defined(__MMI_T9_ROMANIAN__) || defined(__MMI_CSTAR_ROMANIAN__) */  //KP Jerry add "__MMI_CSTAR_ROMANIAN__" on 2007-4-6
  1702.     #if defined(__MMI_T9_SLOVENIAN__) || defined(__MMI_ZI_SLOVENIAN__) || defined(__MMI_CSTAR_SLOVENIAN__) //KP Jerry add "__MMI_CSTAR_SLOVENIAN__" on 2007-4-6
  1703.         case INPUT_MODE_SMART_UPPERCASE_SLOVENIAN:
  1704.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_SLOVENIAN;
  1705.             break;
  1706.         case INPUT_MODE_SMART_LOWERCASE_SLOVENIAN:
  1707.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_SLOVENIAN;
  1708.             break;
  1709.     #endif /* defined(__MMI_T9_SLOVENIAN__) || defined(__MMI_ZI_SLOVENIAN__) || defined(__MMI_CSTAR_SLOVENIAN__) */  //KP Jerry add "__MMI_CSTAR_SLOVENIAN__" on 2007-4-6
  1710.     #if defined(__MMI_T9_GREEK__) || defined(__MMI_ZI_GREEK__) || defined(__MMI_CSTAR_GREEK__) //KP Jerry add "__MMI_CSTAR_GREEK__" on 2007-4-6
  1711.         case INPUT_MODE_SMART_UPPERCASE_GREEK:
  1712.             MMI_current_input_type = INPUT_TYPE_SMART_UPPERCASE_GREEK;
  1713.             break;
  1714.         case INPUT_MODE_SMART_LOWERCASE_GREEK:
  1715.             MMI_current_input_type = INPUT_TYPE_SMART_LOWERCASE_GREEK;
  1716.             break;
  1717.     #endif /* defined(__MMI_T9_GREEK__) || defined(__MMI_ZI_GREEK__) || defined(__MMI_CSTAR_GREEK__) */  //KP Jerry add "__MMI_CSTAR_GREEK__" on 2007-4-6
  1719.     #endif /* defined(__MMI_T9__) || defined(__MMI_ZI__) || defined(__MMI_CSTAR__) || defined(__MMI_KA__) || defined(__MMI_ITAP__) */    //KP Jerry add "__MMI_CSTAR__" on 2007-4-17
  1720.             /* MTK Elvis to add some APIs for Qsearch */
  1721. //KP Jerry modify on 2007-4-18 start
  1722. #ifdef __MMI_LANG_TR_CHINESE__      //KP Jerry add on 2007-4-17
  1723.         case INPUT_MODE_MMI_MULTITAP_BPMF:
  1724.             MMI_current_input_type = INPUT_TYPE_MMI_MULTITAP_BPMF;
  1725.             break;
  1727.         case INPUT_MODE_MMI_TR_STROKE:
  1728.             MMI_current_input_type = INPUT_TYPE_MMI_TR_STROKE;
  1729.             break;
  1730. #endif/*__MMI_LANG_TR_CHINESE__*/      //KP Jerry add on 2007-4-17
  1732. #ifdef __MMI_LANG_SM_CHINESE__      //KP Jerry add on 2007-4-17
  1733.         case INPUT_MODE_MMI_MULTITAP_PINYIN:
  1734.             MMI_current_input_type = INPUT_TYPE_MMI_MULTITAP_PINYIN;
  1735.             break;
  1737.         case INPUT_MODE_MMI_SM_STROKE:
  1738.             MMI_current_input_type = INPUT_TYPE_MMI_SM_STROKE;
  1739.             break;
  1740. #endif/*__MMI_LANG_SM_CHINESE__*/      //KP Jerry add on 2007-4-17
  1741. //KP Jerry modify on 2007-4-18 end
  1743.         case INPUT_MODE_MMI_NUMERIC:
  1744.             MMI_current_input_type = INPUT_TYPE_MMI_NUMERIC;
  1745.             break;
  1747.         case INPUT_MODE_MMI_LOWERCASE_ABC:
  1748.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_ABC;
  1749.             break;
  1750.     #if defined(__MMI_MULTITAP_SPANISH__)
  1751.         case INPUT_MODE_MMI_LOWERCASE_SPANISH:
  1752.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_SPANISH;
  1753.             break;
  1754.     #endif /* defined(__MMI_MULTITAP_SPANISH__) */ 
  1755.     #if defined(__MMI_MULTITAP_DANISH__)
  1756.         case INPUT_MODE_MMI_LOWERCASE_DANISH:
  1757.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_DANISH;
  1758.             break;
  1759.     #endif /* defined(__MMI_MULTITAP_DANISH__) */ 
  1760.     #if defined(__MMI_MULTITAP_POLISH__)
  1761.         case INPUT_MODE_MMI_LOWERCASE_POLISH:
  1762.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_POLISH;
  1763.             break;
  1764.     #endif /* defined(__MMI_MULTITAP_POLISH__) */ 
  1765.     #if defined(__MMI_MULTITAP_FRENCH__)
  1766.         case INPUT_MODE_MMI_LOWERCASE_FRENCH:
  1767.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_FRENCH;
  1768.             break;
  1769.     #endif /* defined(__MMI_MULTITAP_FRENCH__) */ 
  1770.     #if defined(__MMI_MULTITAP_GERMAN__)
  1771.         case INPUT_MODE_MMI_LOWERCASE_GERMAN:
  1772.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_GERMAN;
  1773.             break;
  1774.     #endif /* defined(__MMI_MULTITAP_GERMAN__) */ 
  1775.     #if defined(__MMI_MULTITAP_ITALIAN__)
  1776.         case INPUT_MODE_MMI_LOWERCASE_ITALIAN:
  1777.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_ITALIAN;
  1778.             break;
  1779.     #endif /* defined(__MMI_MULTITAP_ITALIAN__) */ 
  1780.     #if defined(__MMI_MULTITAP_RUSSIAN__)
  1781.         case INPUT_MODE_MMI_LOWERCASE_RUSSIAN:
  1782.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_RUSSIAN;
  1783.             break;
  1784.     #endif /* defined(__MMI_MULTITAP_RUSSIAN__) */ 
  1785.     #if defined(__MMI_MULTITAP_BULGARIAN__)
  1786.         case INPUT_MODE_MMI_LOWERCASE_BULGARIAN:
  1787.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_BULGARIAN;
  1788.             break;
  1789.     #endif /* defined(__MMI_MULTITAP_BULGARIAN__) */ 
  1790.     #if defined(__MMI_MULTITAP_TURKISH__)
  1791.         case INPUT_MODE_MMI_LOWERCASE_TURKISH:
  1792.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_TURKISH;
  1793.             break;
  1794.     #endif /* defined(__MMI_MULTITAP_TURKISH__) */ 
  1795.     #if defined(__MMI_MULTITAP_PORTUGUESE__)
  1796.         case INPUT_MODE_MMI_LOWERCASE_PORTUGUESE:
  1797.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_PORTUGUESE;
  1798.             break;
  1799.     #endif /* defined(__MMI_MULTITAP_PORTUGUESE__) */ 
  1800.     #if defined(__MMI_MULTITAP_INDONESIAN__)
  1801.         case INPUT_MODE_MMI_LOWERCASE_INDONESIAN:
  1802.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_INDONESIAN;
  1803.             break;
  1804.     #endif /* defined(__MMI_MULTITAP_INDONESIAN__) */ 
  1805.     #if defined(__MMI_MULTITAP_CZECH__)
  1806.         case INPUT_MODE_MMI_LOWERCASE_CZECH:
  1807.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_CZECH;
  1808.             break;
  1809.     #endif /* defined(__MMI_MULTITAP_CZECH__) */ 
  1810.     #if defined(__MMI_MULTITAP_MALAY__)
  1811.         case INPUT_MODE_MMI_LOWERCASE_MALAY:
  1812.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_MALAY;
  1813.             break;
  1814.     #endif /* defined(__MMI_MULTITAP_MALAY__) */ 
  1815.     #if defined(__MMI_MULTITAP_VIETNAMESE__)
  1816.         case INPUT_MODE_MMI_LOWERCASE_VIETNAMESE:
  1817.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_VIETNAMESE;
  1818.             break;
  1819.     #endif /* defined(__MMI_MULTITAP_VIETNAMESE__) */ 
  1820.     #if defined(__MMI_MULTITAP_FINNISH__)
  1821.         case INPUT_MODE_MMI_LOWERCASE_FINNISH:
  1822.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_FINNISH;
  1823.             break;
  1824.     #endif /* defined(__MMI_MULTITAP_FINNISH__) */ 
  1825.     #if defined(__MMI_MULTITAP_HUNGARIAN__)
  1826.         case INPUT_MODE_MMI_LOWERCASE_HUNGARIAN:
  1827.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_HUNGARIAN;
  1828.             break;
  1829.     #endif /* defined(__MMI_MULTITAP_HUNGARIAN__) */ 
  1830.     #if defined(__MMI_MULTITAP_SWEDISH__)
  1831.         case INPUT_MODE_MMI_LOWERCASE_SWEDISH:
  1832.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_SWEDISH;
  1833.             break;
  1834.     #endif /* defined(__MMI_MULTITAP_SWEDISH__) */ 
  1835.     #if defined(__MMI_MULTITAP_HEBREW__)
  1836.         case INPUT_MODE_MMI_MULTITAP_HEBREW:
  1837.             MMI_current_input_type = INPUT_TYPE_MMI_MULTITAP_HEBREW;
  1838.             break;
  1839.     #endif /* defined(__MMI_MULTITAP_HEBREW__) */ 
  1840.     #if defined(__MMI_MULTITAP_SLOVAK__)
  1841.         case INPUT_MODE_MMI_LOWERCASE_SLOVAK:
  1842.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_SLOVAK;
  1843.             break;
  1844.     #endif /* defined(__MMI_MULTITAP_SLOVAK__) */ 
  1845.     #if defined(__MMI_MULTITAP_DUTCH__)
  1846.         case INPUT_MODE_MMI_LOWERCASE_DUTCH:
  1847.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_DUTCH;
  1848.             break;
  1849.     #endif /* defined(__MMI_MULTITAP_DUTCH__) */ 
  1850.     #if defined(__MMI_MULTITAP_NORWEGIAN__)
  1851.         case INPUT_MODE_MMI_LOWERCASE_NORWEGIAN:
  1852.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_NORWEGIAN;
  1853.             break;
  1854.     #endif /* defined(__MMI_MULTITAP_NORWEGIAN__) */ 
  1855.     #if defined(__MMI_MULTITAP_ARABIC__)
  1856.         case INPUT_MODE_MMI_MULTITAP_ARABIC:
  1857.             MMI_current_input_type = INPUT_TYPE_MMI_MULTITAP_ARABIC;
  1858.             break;
  1859.     #endif /* defined(__MMI_MULTITAP_ARABIC__) */ 
  1860.     //PMT START PERSIAN
  1861.     #if defined(__MMI_MULTITAP_PERSIAN__)
  1862.          case INPUT_MODE_MMI_MULTITAP_PERSIAN:
  1863.       MMI_current_input_type = INPUT_TYPE_MMI_MULTITAP_PERSIAN;
  1864.       break;
  1865.     #endif          
  1866.     //PMT END PERSIAN
  1868.     #if defined(__MMI_MULTITAP_CROATIAN__)
  1869.         case INPUT_MODE_MMI_LOWERCASE_CROATIAN:
  1870.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_CROATIAN;
  1871.             break;
  1872.     #endif /* defined(__MMI_MULTITAP_CROATIAN__) */ 
  1873.     #if defined(__MMI_MULTITAP_ROMANIAN__)
  1874.         case INPUT_MODE_MMI_LOWERCASE_ROMANIAN:
  1875.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_ROMANIAN;
  1876.             break;
  1877.     #endif /* defined(__MMI_MULTITAP_ROMANIAN__) */ 
  1878.     #if defined(__MMI_MULTITAP_SLOVENIAN__)
  1879.         case INPUT_MODE_MMI_LOWERCASE_SLOVENIAN:
  1880.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_SLOVENIAN;
  1881.             break;
  1882.     #endif /* defined(__MMI_MULTITAP_SLOVENIAN__) */ 
  1883.     #if defined(__MMI_MULTITAP_GREEK__)
  1884.         case INPUT_MODE_MMI_LOWERCASE_GREEK:
  1885.             MMI_current_input_type = INPUT_TYPE_MMI_LOWERCASE_GREEK;
  1886.             break;
  1887.     #endif /* defined(__MMI_MULTITAP_GREEK__) */ 
  1888.     }
  1889.     /* MTK Elvis for R2L characters */
  1890. #ifdef __MMI_BIDI_ALG__
  1891. //PMT START PERSIAN
  1892.     if (MMI_current_input_type == INPUT_TYPE_SMART_ARABIC || MMI_current_input_type == INPUT_TYPE_SMART_HEBREW || MMI_current_input_type == INPUT_TYPE_SMART_PERSIAN)
  1893. //PMT END PERSIAN
  1894.     {
  1895.         MMI_bidi_input_type = BIDI_R;
  1896.     }
  1897.     else
  1898.     {
  1899.         MMI_bidi_input_type = BIDI_L;
  1900.     }
  1902. #endif /* __MMI_BIDI_ALG__ */ 
  1903.     /* MTK end */
  1904. }
  1907. /*****************************************************************************
  1908.  * FUNCTION
  1909.  *  RegisterInputBoxValidationFunction
  1910.  * DESCRIPTION
  1911.  *  register input box validation function
  1912.  * PARAMETERS
  1913.  *  f       [IN]        )(U8*,U8*,S32) function pointer
  1914.  * RETURNS
  1915.  *  void
  1916.  *****************************************************************************/
  1917. void RegisterInputBoxValidationFunction(void (*f) (U8 *, U8 *, S32))
  1918. {
  1919.     /*----------------------------------------------------------------*/
  1920.     /* Local Variables                                                */
  1921.     /*----------------------------------------------------------------*/
  1923.     /*----------------------------------------------------------------*/
  1924.     /* Code Body                                                      */
  1925.     /*----------------------------------------------------------------*/
  1926.     wgui_inputbox_validation_callback = f;
  1927. }
  1930. /*****************************************************************************
  1931.  * FUNCTION
  1932.  *  RegisterInputBoxNotEmptyFunction
  1933.  * DESCRIPTION
  1934.  *  register input box validation function
  1935.  * PARAMETERS
  1936.  *  f       [IN]        )(void) function pointer
  1937.  * RETURNS
  1938.  *  void
  1939.  *****************************************************************************/
  1940. void RegisterInputBoxNotEmptyFunction(void (*f) (void))
  1941. {
  1942.     /*----------------------------------------------------------------*/
  1943.     /* Local Variables                                                */
  1944.     /*----------------------------------------------------------------*/
  1946.     /*----------------------------------------------------------------*/
  1947.     /* Code Body                                                      */
  1948.     /*----------------------------------------------------------------*/
  1949.     wgui_inputbox_not_empty_callback = f;
  1950. }
  1953. /*****************************************************************************
  1954.  * FUNCTION
  1955.  *  RegisterInputBoxEmptyFunction
  1956.  * DESCRIPTION
  1957.  *  register input box validation function
  1958.  * PARAMETERS
  1959.  *  f       [IN]        )(void) function pointer
  1960.  * RETURNS
  1961.  *  void
  1962.  *****************************************************************************/
  1963. void RegisterInputBoxEmptyFunction(void (*f) (void))
  1964. {
  1965.     /*----------------------------------------------------------------*/
  1966.     /* Local Variables                                                */
  1967.     /*----------------------------------------------------------------*/
  1969.     /*----------------------------------------------------------------*/
  1970.     /* Code Body                                                      */
  1971.     /*----------------------------------------------------------------*/
  1972.     wgui_inputbox_empty_callback = f;
  1973. }
  1975. S32(*wgui_inputbox_GSM_ext_count_function) (void) = NULL;
  1976. S32(*wgui_inputbox_UCS2_count_function) (void) = NULL;
  1979. /*****************************************************************************
  1980.  * FUNCTION
  1981.  *  GetInputBoxUCS2Count
  1982.  * DESCRIPTION
  1983.  *  Returns the number of UCS2 characters present
  1984.  *  in the current inputbox buffer
  1985.  * PARAMETERS
  1986.  *  void
  1987.  * RETURNS
  1988.  *  Number of UCS2 characters
  1989.  *****************************************************************************/
  1990. S32 GetInputBoxUCS2Count(void)
  1991. {
  1992.     /*----------------------------------------------------------------*/
  1993.     /* Local Variables                                                */
  1994.     /*----------------------------------------------------------------*/
  1996.     /*----------------------------------------------------------------*/
  1997.     /* Code Body                                                      */
  1998.     /*----------------------------------------------------------------*/
  1999.     if (wgui_inputbox_UCS2_count_function != NULL)
  2000.     {
  2001.         return (wgui_inputbox_UCS2_count_function());
  2002.     }
  2003.     else
  2004.     {
  2005.         return (0);
  2006.     }
  2007. }
  2010. /*****************************************************************************
  2011.  * FUNCTION
  2012.  *  GetInputBoxExtendedGSMCount
  2013.  * DESCRIPTION
  2014.  *  Returns the number of GSM extended characters present
  2015.  *  in the current inputbox buffer.
  2016.  * PARAMETERS
  2017.  *  void
  2018.  * RETURNS
  2019.  *  Number of GSM extended characters
  2020.  *****************************************************************************/
  2021. S32 GetInputBoxExtendedGSMCount(void)
  2022. {
  2023.     /*----------------------------------------------------------------*/
  2024.     /* Local Variables                                                */
  2025.     /*----------------------------------------------------------------*/
  2027.     /*----------------------------------------------------------------*/
  2028.     /* Code Body                                                      */
  2029.     /*----------------------------------------------------------------*/
  2030.     if (wgui_inputbox_GSM_ext_count_function != NULL)
  2031.     {
  2032.         return (wgui_inputbox_GSM_ext_count_function());
  2033.     }
  2034.     else
  2035.     {
  2036.         return (0);
  2037.     }
  2038. }
  2040. /* Common functions for single line input box screens */
  2042. /* Clear / back key handling  */
  2043. /*----------------------------------------------------------------------------
  2044. Function:         wgui_singleline_inputbox_RSK_function
  2045. Description:      a function pointer store the address of function
  2046.                whch handle single input box rsk key
  2047. Input parameters :   none
  2048. Output Parameters:   none
  2049. Returns:       none
  2050. ----------------------------------------------------------------------------*/
  2052. void (*wgui_singleline_inputbox_RSK_function) (void) = UI_dummy_function;
  2054. /* MTK Elvis for QSearch */
  2055. void (*wgui_singleline_inputbox_LSK_function) (void) = UI_dummy_function;
  2057. /* store rsk key string of single input box */
  2058. UI_string_type wgui_singleline_inputbox_LSK_label_string;
  2060. /* store rsk key icon of single input box */
  2061. PU8 wgui_singleline_inputbox_LSK_label_icon;
  2063. U8 wgui_singleline_inputbox_RSK_label_clear = 0;
  2065. /* store rsk key string of single input box */
  2066. UI_string_type wgui_singleline_inputbox_RSK_label_string;
  2068. /* store rsk key icon of single input box */
  2069. PU8 wgui_singleline_inputbox_RSK_label_icon;
  2071. /* store flag of decimal input of single input box */
  2072. U8 wgui_singleline_inputbox_decimal_flag = 0;
  2074. /* store flag of decimal input of mode single input box */
  2075. U8 wgui_singleline_inputbox_decimal_input_mode_flag = 0;
  2077. /* store buffer size of single input box */
  2078. S32 wgui_singleline_inputbox_buffer_size = 0;
  2080. /* MTK end */
  2083. /*****************************************************************************
  2084.  * FUNCTION
  2085.  *  wgui_handle_singleline_inputbox_right_softkey_down
  2086.  * DESCRIPTION
  2087.  *  handle single line input box RSK down key
  2088.  * PARAMETERS
  2089.  *  void
  2090.  * RETURNS
  2091.  *  void
  2092.  *****************************************************************************/
  2093. /* MTK ELvis 20040104 */
  2094. extern void PbookListSearchEntryReq(void);
  2095. extern U8 inPinyinSearchScreen;
  2096. void refresh_search_list(U8 *name);
  2098. extern S32(*cat200_search_function) (U8 *);
  2100. void wgui_handle_singleline_inputbox_right_softkey_down(void)
  2101. {
  2102.     /*----------------------------------------------------------------*/
  2103.     /* Local Variables                                                */
  2104.     /*----------------------------------------------------------------*/
  2106.     /*----------------------------------------------------------------*/
  2107.     /* Code Body                                                      */
  2108.     /*----------------------------------------------------------------*/
  2109.     if (wgui_singleline_inputbox_decimal_input_mode_flag)
  2110.     {
  2111.         if (wgui_singleline_inputbox_decimal_flag)
  2112.         {
  2113.             UI_buffer_type p = MMI_singleline_inputbox.current_text_p;
  2114.             UI_character_type c;
  2116.             if (p != MMI_singleline_inputbox.text)
  2117.             {
  2118.                 UI_STRING_GET_PREVIOUS_CHARACTER(p, c);
  2119.                 if (c == (UI_character_type) '.')
  2120.                 {
  2121.                     wgui_singleline_inputbox_decimal_flag = 0;
  2122.                 }
  2123.             }
  2124.         }
  2125.         if (gui_single_line_input_box_get_text_length(&MMI_singleline_inputbox) > 0)
  2126.         {
  2127.             singleline_inputbox_delete_character();
  2128.         }
  2129.     }
  2130.     else
  2131.     {
  2132.         if (gui_single_line_input_box_get_text_length(&MMI_singleline_inputbox) > 0)
  2133.         {
  2134.             singleline_inputbox_delete_character();
  2135.             /* MTK Elvis 20040527--if the text buffer length is zero, it's not required to call this function to redraw screen */
  2136.             if (cat200_search_function)
  2137.             {
  2138.                 refresh_search_list(MMI_singleline_inputbox.text);
  2139.             }
  2140.             /* MTK end */
  2142.         #ifdef __MMI_PINYIN_SEARCH__
  2143.             if (inPinyinSearchScreen)
  2144.             {
  2145.                 PbookListSearchEntryReq();
  2146.             }
  2147.         #endif /* __MMI_PINYIN_SEARCH__ */ 
  2148.         }
  2149.     }
  2151. }
  2154. /*****************************************************************************
  2155.  * FUNCTION
  2156.  *  wgui_handle_singleline_inputbox_right_softkey_up
  2157.  * DESCRIPTION
  2158.  *  handle single line input box RSK up  key
  2159.  * PARAMETERS
  2160.  *  void
  2161.  * RETURNS
  2162.  *  void
  2163.  *****************************************************************************/
  2164. void wgui_handle_singleline_inputbox_right_softkey_up(void)
  2165. {
  2166.     /*----------------------------------------------------------------*/
  2167.     /* Local Variables                                                */
  2168.     /*----------------------------------------------------------------*/
  2170.     /*----------------------------------------------------------------*/
  2171.     /* Code Body                                                      */
  2172.     /*----------------------------------------------------------------*/
  2173.     if (wgui_singleline_inputbox_RSK_function != NULL)
  2174.     {
  2175.         wgui_singleline_inputbox_RSK_function();
  2176.     }
  2177. }
  2180. /*****************************************************************************
  2181.  * FUNCTION
  2182.  *  wgui_register_singleline_inputbox_handle_right_softkey_up
  2183.  * DESCRIPTION
  2184.  *  register a function handler of RSK up key of single input box
  2185.  * PARAMETERS
  2186.  *  void
  2187.  * RETURNS
  2188.  *  void
  2189.  *****************************************************************************/
  2190. void wgui_register_singleline_inputbox_handle_right_softkey_up(void)
  2191. {
  2192.     /*----------------------------------------------------------------*/
  2193.     /* Local Variables                                                */
  2194.     /*----------------------------------------------------------------*/
  2196.     /*----------------------------------------------------------------*/
  2197.     /* Code Body                                                      */
  2198.     /*----------------------------------------------------------------*/
  2199.     set_right_softkey_function(wgui_handle_singleline_inputbox_right_softkey_up, KEY_EVENT_UP);
  2200. }
  2203. /*****************************************************************************
  2204.  * FUNCTION
  2205.  *  wgui_register_singleline_inputbox_handle_clear_key_up
  2206.  * DESCRIPTION
  2207.  *  register a function handler of RSK up key of single input box
  2208.  * PARAMETERS
  2209.  *  void
  2210.  * RETURNS
  2211.  *  void
  2212.  *****************************************************************************/
  2213. void wgui_register_singleline_inputbox_handle_clear_key_up(void)
  2214. {
  2215.     /*----------------------------------------------------------------*/
  2216.     /* Local Variables                                                */
  2217.     /*----------------------------------------------------------------*/
  2219.     /*----------------------------------------------------------------*/
  2220.     /* Code Body                                                      */
  2221.     /*----------------------------------------------------------------*/
  2222.     SetKeyHandler(wgui_handle_singleline_inputbox_right_softkey_up, KEY_CLEAR, KEY_EVENT_UP);
  2223. }
  2226. /*****************************************************************************
  2227.  * FUNCTION
  2228.  *  wgui_handle_singleline_inputbox_right_softkey_long_press
  2229.  * DESCRIPTION
  2230.  *  handle long press of RSK of single input box
  2231.  * PARAMETERS
  2232.  *  void
  2233.  * RETURNS
  2234.  *  void
  2235.  *****************************************************************************/
  2236. void wgui_handle_singleline_inputbox_right_softkey_long_press(void)
  2237. {
  2238.     /*----------------------------------------------------------------*/
  2239.     /* Local Variables                                                */
  2240.     /*----------------------------------------------------------------*/
  2242.     /*----------------------------------------------------------------*/
  2243.     /* Code Body                                                      */
  2244.     /*----------------------------------------------------------------*/
  2245.     singleline_inputbox_delete_all_characters();
  2246.     if (wgui_singleline_inputbox_decimal_input_mode_flag)
  2247.     {
  2248.         wgui_singleline_inputbox_decimal_flag = 0;
  2249.     }
  2250.     /* MTK Terry 20041111--if the text buffer length is zero, it's required to call this function to redraw screen */
  2251.     if (cat200_search_function)
  2252.     {
  2253.         refresh_search_list(MMI_singleline_inputbox.text);
  2254.     }
  2255.     /* MTK end */
  2256. }
  2259. /*****************************************************************************
  2260.  * FUNCTION
  2261.  *  wgui_handle_singleline_inputbox_input
  2262.  * DESCRIPTION
  2263.  *  handle input of single line input box
  2264.  * PARAMETERS
  2265.  *  void
  2266.  * RETURNS
  2267.  *  void
  2268.  *****************************************************************************/
  2269. void wgui_handle_singleline_inputbox_input(void)
  2270. {
  2271.     /*----------------------------------------------------------------*/
  2272.     /* Local Variables                                                */
  2273.     /*----------------------------------------------------------------*/
  2275.     /*----------------------------------------------------------------*/
  2276.     /* Code Body                                                      */
  2277.     /*----------------------------------------------------------------*/
  2278.     if (gui_single_line_input_box_get_text_length(&MMI_singleline_inputbox) > 0)
  2279.     {
  2280.     #if defined(__MMI_WITH_C_KEY__)
  2281.         if (wgui_singleline_inputbox_RSK_label_clear == 0)
  2282.         {
  2283.             if (wgui_inputbox_not_empty_callback != NULL)
  2284.             {
  2285.                 wgui_inputbox_not_empty_callback();
  2286.             }
  2287.             wgui_singleline_inputbox_RSK_label_clear = 1;
  2288.             SetKeyHandler(wgui_handle_singleline_inputbox_right_softkey_down, KEY_CLEAR, KEY_EVENT_DOWN);
  2289.             SetKeyHandler(UI_dummy_function, KEY_CLEAR, KEY_EVENT_UP);
  2290.             SetKeyHandler(wgui_handle_singleline_inputbox_right_softkey_long_press, KEY_CLEAR, KEY_EVENT_LONG_PRESS);
  2292.         }
  2293.     #else /* defined(__MMI_WITH_C_KEY__) */ 
  2294.         if (wgui_singleline_inputbox_RSK_label_clear == 0)
  2295.         {
  2296.             set_right_softkey_label((UI_string_type) get_string(WGUI_CATEGORY_CLEAR_STRING_ID));
  2297.             set_right_softkey_icon(NULL);
  2298.             if (wgui_inputbox_not_empty_callback != NULL)
  2299.             {
  2300.                 wgui_inputbox_not_empty_callback();
  2301.             }
  2302.             redraw_right_softkey();
  2303.             wgui_singleline_inputbox_RSK_label_clear = 1;
  2304.             set_right_softkey_function(UI_dummy_function, KEY_EVENT_UP);
  2305.             set_right_softkey_function(wgui_handle_singleline_inputbox_right_softkey_down, KEY_EVENT_DOWN);
  2306.         }
  2307.     #endif /* defined(__MMI_WITH_C_KEY__) */ 
  2308.     }
  2309.     else
  2310.     {
  2311.     #if defined(__MMI_WITH_C_KEY__)
  2312.         if (wgui_singleline_inputbox_RSK_label_clear == 1)
  2313.         {
  2314.             if (wgui_inputbox_empty_callback != NULL)
  2315.             {
  2316.                 wgui_inputbox_empty_callback();
  2317.             }
  2318.             wgui_singleline_inputbox_RSK_label_clear = 0;
  2319.             SetKeyHandler(UI_dummy_function, KEY_CLEAR, KEY_EVENT_DOWN);
  2320.             /* MTK Terry Temp solution for C key in Enter Pin */
  2321.             SetKeyHandler(UI_dummy_function, KEY_CLEAR, KEY_EVENT_UP);
  2322.             SetKeyHandler(UI_dummy_function, KEY_CLEAR, KEY_EVENT_LONG_PRESS);
  2324.         }
  2325.     #else /* defined(__MMI_WITH_C_KEY__) */ 
  2327.         if (wgui_singleline_inputbox_RSK_label_clear == 1)
  2328.         {
  2329.             set_right_softkey_label(wgui_singleline_inputbox_RSK_label_string);
  2330.             set_right_softkey_icon(wgui_singleline_inputbox_RSK_label_icon);
  2331.             if (wgui_inputbox_empty_callback != NULL)
  2332.             {
  2333.                 wgui_inputbox_empty_callback();
  2334.             }
  2335.             redraw_right_softkey();
  2336.             wgui_singleline_inputbox_RSK_label_clear = 0;
  2337.             set_right_softkey_function(wgui_register_singleline_inputbox_handle_right_softkey_up, KEY_EVENT_UP);
  2338.             set_right_softkey_function(UI_dummy_function, KEY_EVENT_DOWN);
  2339.         }
  2341.     #endif /* defined(__MMI_WITH_C_KEY__) */ 
  2342.     }
  2343. #if(0)
  2344. if(pixtel_UI_single_line_input_box_test_first_position(&MMI_singleline_inputbox))
  2345. {
  2346. if(wgui_singleline_inputbox_RSK_label_clear==1)
  2347. {
  2348. set_right_softkey_label(wgui_singleline_inputbox_RSK_label_string);
  2349. set_right_softkey_icon(wgui_singleline_inputbox_RSK_label_icon);
  2350. redraw_right_softkey();
  2351. wgui_singleline_inputbox_RSK_label_clear=0;
  2352. set_right_softkey_function(wgui_register_singleline_inputbox_handle_right_softkey_up,KEY_EVENT_UP);
  2353. set_right_softkey_function(UI_dummy_function,KEY_EVENT_DOWN);
  2354. }
  2355. }
  2356. #endif /* (0) */ 
  2357.     if (MMI_singleline_inputbox.flags & UI_SINGLE_LINE_INPUT_BOX_PLUS_CHARACTER_HANDLING)
  2358.     {
  2359.         if (MMI_singleline_inputbox.text[0] == '+')
  2360.         {
  2361.             MMI_singleline_inputbox.available_length = (wgui_singleline_inputbox_buffer_size + 1) * ENCODING_LENGTH;
  2362.         }
  2363.         else
  2364.         {
  2365.             MMI_singleline_inputbox.available_length = wgui_singleline_inputbox_buffer_size * ENCODING_LENGTH;
  2366.         }
  2367.     }
  2368.     //MTK Elvis 20040517 to turn on this    
  2369.     //Draw Information Bar If Enable - Gurinder - 23/4/2004
  2370.     if (wgui_inputbox_information_flag)
  2371.     {
  2372.         wgui_redraw_singleline_input_information_bar();
  2373.     }
  2374.     /* MTK end */
  2375. }
  2378. /*****************************************************************************
  2379.  * FUNCTION
  2380.  *  wgui_handle_singleline_inputbox_navigate
  2381.  * DESCRIPTION
  2382.  *  handle navigation  of single line input box
  2383.  * PARAMETERS
  2384.  *  void
  2385.  * RETURNS
  2386.  *  void
  2387.  *****************************************************************************/
  2388. void wgui_handle_singleline_inputbox_navigate(void)
  2389. {
  2390.     /*----------------------------------------------------------------*/
  2391.     /* Local Variables                                                */
  2392.     /*----------------------------------------------------------------*/
  2394.     /*----------------------------------------------------------------*/
  2395.     /* Code Body                                                      */
  2396.     /*----------------------------------------------------------------*/
  2397.     if (gui_single_line_input_box_test_first_position(&MMI_singleline_inputbox) ||
  2398.         (gui_single_line_input_box_get_text_length(&MMI_singleline_inputbox) <= 0))
  2399.     {
  2400.         if (wgui_singleline_inputbox_RSK_label_clear == 1)
  2401.         {
  2402.             set_right_softkey_label(wgui_singleline_inputbox_RSK_label_string);
  2403.             set_right_softkey_icon(wgui_singleline_inputbox_RSK_label_icon);
  2404.             redraw_right_softkey();
  2405.             wgui_singleline_inputbox_RSK_label_clear = 0;
  2406.             set_right_softkey_function(wgui_handle_singleline_inputbox_right_softkey_up, KEY_EVENT_UP);
  2407.             set_right_softkey_function(UI_dummy_function, KEY_EVENT_DOWN);
  2408.         }
  2409.     }
  2410.     else
  2411.     {
  2412.         if (wgui_singleline_inputbox_RSK_label_clear == 0)
  2413.         {
  2414.             set_right_softkey_label((UI_string_type) get_string(WGUI_CATEGORY_CLEAR_STRING_ID));
  2415.             set_right_softkey_icon(NULL);
  2416.             redraw_right_softkey();
  2417.             wgui_singleline_inputbox_RSK_label_clear = 1;
  2418.             set_right_softkey_function(UI_dummy_function, KEY_EVENT_UP);
  2419.             set_right_softkey_function(wgui_handle_singleline_inputbox_right_softkey_down, KEY_EVENT_DOWN);
  2420.         }
  2421.     }
  2422. }
  2424. /* Multitap handling for phone number input mode   */
  2425. /*----------------------------------------------------------------------------
  2426. Function:         wgui_singleline_inputbox_phone_number_input_complete_multitap_star_key
  2427. Description:      handle multital star key of phone number input box
  2428. Input parameters :   none
  2429. Output Parameters:   none
  2430. Returns:       none
  2431. ----------------------------------------------------------------------------*/
  2432. void wgui_singleline_inputbox_phone_number_input_complete_multitap_star_key(void);
  2434. /*----------------------------------------------------------------------------
  2435. Function:         wgui_singleline_inputbox_phone_number_input_complete_multitap_zero_key
  2436. Description:      handle multitap zero key of phone number input box
  2437. Input parameters :   none
  2438. Output Parameters:   none
  2439. Returns:       none
  2440. ----------------------------------------------------------------------------*/
  2441. void wgui_singleline_inputbox_phone_number_input_complete_multitap_zero_key(void);
  2444. /*****************************************************************************
  2445.  * FUNCTION
  2446.  *  wgui_singleline_inputbox_handle_multitap_input_complete
  2447.  * DESCRIPTION
  2448.  *  handle multitap input complete of single line input box
  2449.  * PARAMETERS
  2450.  *  type        [IN]        Type  of multitap select
  2451.  * RETURNS
  2452.  *  void
  2453.  *****************************************************************************/
  2454. void wgui_singleline_inputbox_handle_multitap_input_complete(S32 type)
  2455. {
  2456.     /*----------------------------------------------------------------*/
  2457.     /* Local Variables                                                */
  2458.     /*----------------------------------------------------------------*/
  2460.     /*----------------------------------------------------------------*/
  2461.     /* Code Body                                                      */
  2462.     /*----------------------------------------------------------------*/
  2463.     if (wgui_inputbox_active_multitap == WGUI_INPUTBOX_MULTITAP_NONE)
  2464.     {
  2465.         return;
  2466.     }
  2467.     switch (wgui_inputbox_active_multitap)
  2468.     {
  2469.         case WGUI_INPUTBOX_EDIT_MULTITAP_STAR:
  2470.             if (type == WGUI_INPUTBOX_EDIT_MULTITAP_STAR)
  2471.             {
  2472.                 return;
  2473.             }
  2474.             if (MMI_singleline_inputbox.flags & UI_SINGLE_LINE_INPUT_BOX_STATE_MULTITAP)
  2475.             {
  2476.                 gui_cancel_timer(wgui_singleline_inputbox_phone_number_input_complete_multitap_star_key);
  2477.                 gui_multitap_input_complete(&wgui_inputbox_multitap_star_key);
  2478.             }
  2479.             break;
  2480.         #ifdef __MMI_MULTITAP_KEY_0__
  2482.         case WGUI_INPUTBOX_EDIT_MULTITAP_ZERO:
  2483.             if (type == WGUI_INPUTBOX_EDIT_MULTITAP_ZERO)
  2484.             {
  2485.                 return;
  2486.             }
  2487.             if (MMI_singleline_inputbox.flags & UI_SINGLE_LINE_INPUT_BOX_STATE_MULTITAP)
  2488.             {
  2489.                 gui_cancel_timer(wgui_singleline_inputbox_phone_number_input_complete_multitap_zero_key);
  2490.                 gui_multitap_input_complete(&wgui_inputbox_multitap_zero_key);
  2491.             }
  2492.             break;
  2493.         #endif /* __MMI_MULTITAP_KEY_0__ */ 
  2494.     }
  2495.     wgui_inputbox_active_multitap = WGUI_INPUTBOX_MULTITAP_NONE;
  2496. }
  2499. /*****************************************************************************
  2500.  * FUNCTION
  2501.  *  wgui_singleline_inputbox_phone_number_input_complete_multitap_star_key
  2502.  * DESCRIPTION
  2503.  *  handle multitap input complete of single line phone number input box
  2504.  * PARAMETERS
  2505.  *  void
  2506.  * RETURNS
  2507.  *  void
  2508.  *****************************************************************************/
  2509. void wgui_singleline_inputbox_phone_number_input_complete_multitap_star_key(void)
  2510. {
  2511.     /*----------------------------------------------------------------*/
  2512.     /* Local Variables                                                */
  2513.     /*----------------------------------------------------------------*/
  2515.     /*----------------------------------------------------------------*/
  2516.     /* Code Body                                                      */
  2517.     /*----------------------------------------------------------------*/
  2518.     gui_multitap_input_complete(&wgui_inputbox_multitap_star_key);
  2519. }
  2522. /*****************************************************************************
  2523.  * FUNCTION
  2524.  *  wgui_singleline_inputbox_phone_number_input_handle_multitap_star_key_down
  2525.  * DESCRIPTION
  2526.  *  handle multitap input complete of single line phone numebr start keyx
  2527.  * PARAMETERS
  2528.  *  void
  2529.  * RETURNS
  2530.  *  void
  2531.  *****************************************************************************/
  2532. void wgui_singleline_inputbox_phone_number_input_handle_multitap_star_key_down(void)
  2533. {
  2534.     /*----------------------------------------------------------------*/
  2535.     /* Local Variables                                                */
  2536.     /*----------------------------------------------------------------*/
  2538.     /*----------------------------------------------------------------*/
  2539.     /* Code Body                                                      */
  2540.     /*----------------------------------------------------------------*/
  2541.     wgui_singleline_inputbox_handle_multitap_input_complete(WGUI_INPUTBOX_EDIT_MULTITAP_STAR);
  2542.     wgui_inputbox_active_multitap = WGUI_INPUTBOX_EDIT_MULTITAP_STAR;
  2543.     gui_change_multitap_input_state(&wgui_inputbox_multitap_star_key);
  2544. }
  2547. /*****************************************************************************
  2548.  * FUNCTION
  2549.  *  wgui_singleline_inputbox_phone_number_input_handle_multitap_star_key_up
  2550.  * DESCRIPTION
  2551.  *  handle multitap input complete of single line phone numebr start key up
  2552.  * PARAMETERS
  2553.  *  void
  2554.  * RETURNS
  2555.  *  void
  2556.  *****************************************************************************/
  2557. void wgui_singleline_inputbox_phone_number_input_handle_multitap_star_key_up(void)
  2558. {
  2559.     /*----------------------------------------------------------------*/
  2560.     /* Local Variables                                                */
  2561.     /*----------------------------------------------------------------*/
  2563.     /*----------------------------------------------------------------*/
  2564.     /* Code Body                                                      */
  2565.     /*----------------------------------------------------------------*/
  2566.     gui_start_timer(MMI_MULTITAP_TIMEOUT, wgui_singleline_inputbox_phone_number_input_complete_multitap_star_key);
  2567. }
  2569. #ifdef __MMI_MULTITAP_KEY_0__
  2572. /*****************************************************************************
  2573.  * FUNCTION
  2574.  *  wgui_singleline_inputbox_phone_number_input_complete_multitap_zero_key
  2575.  * DESCRIPTION
  2576.  *  handle multitap input complete of single line phone numebr zero key
  2577.  * PARAMETERS
  2578.  *  void
  2579.  * RETURNS
  2580.  *  void
  2581.  *****************************************************************************/
  2582. void wgui_singleline_inputbox_phone_number_input_complete_multitap_zero_key(void)
  2583. {
  2584.     /*----------------------------------------------------------------*/
  2585.     /* Local Variables                                                */
  2586.     /*----------------------------------------------------------------*/
  2588.     /*----------------------------------------------------------------*/
  2589.     /* Code Body                                                      */
  2590.     /*----------------------------------------------------------------*/
  2591.     gui_multitap_input_complete(&wgui_inputbox_multitap_zero_key);
  2592.     SetKeyHandler(MMI_key_0_down, KEY_0, KEY_EVENT_DOWN);
  2593.     SetKeyHandler(MMI_key_0_down, KEY_0, KEY_REPEAT);
  2594.     SetKeyHandler(MMI_key_0_up, KEY_0, KEY_EVENT_UP);
  2596. }
  2599. /*****************************************************************************
  2600.  * FUNCTION
  2601.  *  wgui_singleline_inputbox_phone_number_input_handle_multitap_zero_key_down
  2602.  * DESCRIPTION
  2603.  *  handle multitap input complete of single line phone numebr zero key down
  2604.  * PARAMETERS
  2605.  *  void
  2606.  * RETURNS
  2607.  *  void
  2608.  *****************************************************************************/
  2609. void wgui_singleline_inputbox_phone_number_input_handle_multitap_zero_key_down(void)
  2610. {
  2611.     /*----------------------------------------------------------------*/
  2612.     /* Local Variables                                                */
  2613.     /*----------------------------------------------------------------*/
  2615.     /*----------------------------------------------------------------*/
  2616.     /* Code Body                                                      */
  2617.     /*----------------------------------------------------------------*/
  2618.     wgui_singleline_inputbox_handle_multitap_input_complete(WGUI_INPUTBOX_EDIT_MULTITAP_ZERO);
  2619.     wgui_inputbox_active_multitap = WGUI_INPUTBOX_EDIT_MULTITAP_ZERO;
  2620.     gui_change_multitap_input_state(&wgui_inputbox_multitap_zero_key);
  2621. }
  2624. /*****************************************************************************
  2625.  * FUNCTION
  2626.  *  wgui_singleline_inputbox_phone_number_input_handle_multitap_zero_key_up
  2627.  * DESCRIPTION
  2628.  *  handle multitap input complete of single line phone numebr zero key up
  2629.  * PARAMETERS
  2630.  *  void
  2631.  * RETURNS
  2632.  *  void
  2633.  *****************************************************************************/
  2634. void wgui_singleline_inputbox_phone_number_input_handle_multitap_zero_key_up(void)
  2635. {
  2636.     /*----------------------------------------------------------------*/
  2637.     /* Local Variables                                                */
  2638.     /*----------------------------------------------------------------*/
  2640.     /*----------------------------------------------------------------*/
  2641.     /* Code Body                                                      */
  2642.     /*----------------------------------------------------------------*/
  2643.     gui_start_timer(MMI_MULTITAP_TIMEOUT + 400, wgui_singleline_inputbox_phone_number_input_complete_multitap_zero_key);
  2644. }
  2647. /*****************************************************************************
  2648.  * FUNCTION
  2649.  *  wgui_singleline_inputbox_phone_number_input_handle_zero_key_long_press
  2650.  * DESCRIPTION
  2651.  *  handle long press zero key on phone number input box
  2652.  * PARAMETERS
  2653.  *  void
  2654.  * RETURNS
  2655.  *  void
  2656.  *****************************************************************************/
  2657. void wgui_singleline_inputbox_phone_number_input_handle_zero_key_long_press(void)
  2658. {
  2659.     /*----------------------------------------------------------------*/
  2660.     /* Local Variables                                                */
  2661.     /*----------------------------------------------------------------*/
  2663.     /*----------------------------------------------------------------*/
  2664.     /* Code Body                                                      */
  2665.     /*----------------------------------------------------------------*/
  2666.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_REPEAT);
  2667.     singleline_inputbox_delete_character();