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

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

MTK

开发平台：

C/C++

EditorPen.c：源码内容
  3. /*****************************************************************************
  4.  * FUNCTION
  5.  *  mmi_pen_editor_reset_composition_index
  6.  * DESCRIPTION
  7.  *  Reset the current index and the currect page for the composition box
  8.  * PARAMETERS
  9.  *  void
  10.  * RETURNS
  11.  *  void
  12.  *****************************************************************************/
  13. void mmi_pen_editor_reset_composition_index(void)
  14. {
  15.     /*----------------------------------------------------------------*/
  16.     /* Local Variables                                                */
  17.     /*----------------------------------------------------------------*/
  19.     /*----------------------------------------------------------------*/
  20.     /* Code Body                                                      */
  21.     /*----------------------------------------------------------------*/
  22.     g_pen_editor_composition_index = 0;
  23.     g_pen_editor_composition_page = 0;
  24. }
  27. /*****************************************************************************
  28.  * FUNCTION
  29.  *  mmi_pen_editor_set_CSK_content
  30.  * DESCRIPTION
  31.  *  Set the CSK content by the input method
  32.  * PARAMETERS
  33.  *  void
  34.  * RETURNS
  35.  *  void
  36.  *****************************************************************************/
  37. void mmi_pen_editor_set_CSK_content(void)
  38. {
  39. #ifdef __MMI_WGUI_CSK_ENABLE__
  40.     /*----------------------------------------------------------------*/
  41.     /* Local Variables                                                */
  42.     /*----------------------------------------------------------------*/
  43.     /* W05.36 Add Center Soft Key for switching Input Method */
  44.     UI_string_type inputmode_string = NULL;
  45.     PU8 inputbox_information_icon = NULL;
  46.     U16 name[] = {0x0};
  48. #if defined(__MMI_LANG_MARATHI__)
  49.     U16 input_mode_marathi_string_array[] = {C_MA, C_RA, DV_AA, C_TTHA, DV_II, 0x0};
  50. #endif /* defined(__MMI_LANG_MARATHI__) */    
  52.     /*----------------------------------------------------------------*/
  53.     /* Code Body                                                      */
  54.     /*----------------------------------------------------------------*/
  55.     set_softkey_label(NULL, MMI_CENTER_SOFTKEY);
  56.     set_softkey_icon(NULL, MMI_CENTER_SOFTKEY);
  58.     switch (MMI_current_input_mode)
  59.     {
  60.         case INPUT_MODE_SMART_UPPERCASE_ABC:
  61.             inputbox_information_icon = get_image(WGUI_IME_SMART_ENGLISH_IMG);
  62.         case INPUT_MODE_MULTITAP_UPPERCASE_ABC:
  63.         case INPUT_MODE_MULTITAP_UPPERCASE_ABC_NO_NUMERIC:
  64.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_ABC_STRING_ID);
  65.             break;
  67.         case INPUT_MODE_SMART_LOWERCASE_ABC:
  68.             inputbox_information_icon = get_image(WGUI_IME_SMART_ENGLISH_IMG);
  69.         case INPUT_MODE_MULTITAP_LOWERCASE_ABC:
  70.         case INPUT_MODE_MMI_LOWERCASE_ABC:
  71.         case INPUT_MODE_MULTITAP_LOWERCASE_ABC_NO_NUMERIC:
  72.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_abc_STRING_ID);
  73.             break;
  75. #ifdef __MMI_LANG_THAI__    //KP Jerry add on 2007-4-29
  76.         case INPUT_MODE_MULTITAP_THAI:
  77.         case INPUT_MODE_MMI_MULTITAP_THAI:
  78.         case INPUT_MODE_SMART_THAI:
  79.             inputmode_string=(UI_string_type)get_string(WGUI_CATEGORY_thai_STRING_ID);    //KP Jerry enable on 2007-4-29
  80.             break;
  81. #endif    //KP Jerry add on 2007-4-29
  83.         case INPUT_MODE_MULTITAP_UPPERCASE_SPANISH:
  84.         case INPUT_MODE_SMART_UPPERCASE_SPANISH:
  85.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_SPANISH_STRING_ID);
  86.             break;
  88.         case INPUT_MODE_MULTITAP_LOWERCASE_SPANISH:
  89.         case INPUT_MODE_MMI_LOWERCASE_SPANISH:
  90.         case INPUT_MODE_SMART_LOWERCASE_SPANISH:
  91.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_spanish_STRING_ID);
  92.             break;
  94.         case INPUT_MODE_MULTITAP_UPPERCASE_DANISH:
  95.         case INPUT_MODE_SMART_UPPERCASE_DANISH:
  96.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_DANISH_STRING_ID);
  97.             break;
  99.         case INPUT_MODE_MULTITAP_LOWERCASE_DANISH:
  100.         case INPUT_MODE_MMI_LOWERCASE_DANISH:
  101.         case INPUT_MODE_SMART_LOWERCASE_DANISH:
  102.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_danish_STRING_ID);
  103.             break;
  105.         case INPUT_MODE_MULTITAP_UPPERCASE_FRENCH:
  106.         case INPUT_MODE_SMART_UPPERCASE_FRENCH:
  107.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_FRENCH_STRING_ID);
  108.             break;
  110.         case INPUT_MODE_MULTITAP_LOWERCASE_FRENCH:
  111.         case INPUT_MODE_MMI_LOWERCASE_FRENCH:
  112.         case INPUT_MODE_SMART_LOWERCASE_FRENCH:
  113.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_french_STRING_ID);
  114.             break;
  116.         case INPUT_MODE_MULTITAP_UPPERCASE_GERMAN:
  117.         case INPUT_MODE_SMART_UPPERCASE_GERMAN:
  118.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_GERMAN_STRING_ID);
  119.             break;
  121.         case INPUT_MODE_MULTITAP_LOWERCASE_GERMAN:
  122.         case INPUT_MODE_MMI_LOWERCASE_GERMAN:
  123.         case INPUT_MODE_SMART_LOWERCASE_GERMAN:
  124.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_german_STRING_ID);
  125.             break;
  127.         case INPUT_MODE_MULTITAP_UPPERCASE_ITALIAN:
  128.         case INPUT_MODE_SMART_UPPERCASE_ITALIAN:
  129.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_ITALIAN_STRING_ID);
  130.             break;
  132.         case INPUT_MODE_MULTITAP_LOWERCASE_ITALIAN:
  133.         case INPUT_MODE_MMI_LOWERCASE_ITALIAN:
  134.         case INPUT_MODE_SMART_LOWERCASE_ITALIAN:
  135.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_italian_STRING_ID);
  136.             break;
  138.         case INPUT_MODE_MULTITAP_UPPERCASE_RUSSIAN:
  139.         case INPUT_MODE_SMART_UPPERCASE_RUSSIAN:
  140.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_RUSSIAN_STRING_ID);
  141.             break;
  143.         case INPUT_MODE_MULTITAP_LOWERCASE_RUSSIAN:
  144.         case INPUT_MODE_MMI_LOWERCASE_RUSSIAN:
  145.         case INPUT_MODE_SMART_LOWERCASE_RUSSIAN:
  146.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_russian_STRING_ID);
  147.             break;
  149.         case INPUT_MODE_MULTITAP_UPPERCASE_TURKISH:
  150.         case INPUT_MODE_SMART_UPPERCASE_TURKISH:
  151.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_TURKISH_STRING_ID);
  152.             break;
  154.         case INPUT_MODE_MULTITAP_LOWERCASE_TURKISH:
  155.         case INPUT_MODE_MMI_LOWERCASE_TURKISH:
  156.         case INPUT_MODE_SMART_LOWERCASE_TURKISH:
  157.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_turkish_STRING_ID);
  158.             break;
  160.         case INPUT_MODE_MULTITAP_UPPERCASE_PORTUGUESE:
  161.         case INPUT_MODE_SMART_UPPERCASE_PORTUGUESE:
  162.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_PORTUGUESE_STRING_ID);
  163.             break;
  165.         case INPUT_MODE_MULTITAP_LOWERCASE_PORTUGUESE:
  166.         case INPUT_MODE_MMI_LOWERCASE_PORTUGUESE:
  167.         case INPUT_MODE_SMART_LOWERCASE_PORTUGUESE:
  168.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_portuguese_STRING_ID);
  169.             break;
  171.         case INPUT_MODE_MULTITAP_HINDI:
  172.             inputmode_string = (UI_string_type) name;
  173.             break;
  174.             
  175.     #if defined(__MMI_LANG_MARATHI__)
  176.         case INPUT_MODE_MULTITAP_MARATHI:
  177.             inputmode_string = (UI_string_type) input_mode_marathi_string_array;
  178.             break;
  179.     #endif /* defined(__MMI_LANG_MARATHI__) */ 
  180.             
  182.         case INPUT_MODE_MULTITAP_UPPERCASE_INDONESIAN:
  183.         case INPUT_MODE_SMART_UPPERCASE_INDONESIAN:
  184.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_INDONESIAN_STRING_ID);
  185.             break;
  187.         case INPUT_MODE_MULTITAP_LOWERCASE_INDONESIAN:
  188.         case INPUT_MODE_MMI_LOWERCASE_INDONESIAN:
  189.         case INPUT_MODE_SMART_LOWERCASE_INDONESIAN:
  190.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_indonesian_STRING_ID);
  191.             break;
  193.         case INPUT_MODE_MULTITAP_UPPERCASE_MALAY:
  194.         case INPUT_MODE_SMART_UPPERCASE_MALAY:
  195.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_MALAY_STRING_ID);
  196.             break;
  198.         case INPUT_MODE_MULTITAP_LOWERCASE_MALAY:
  199.         case INPUT_MODE_MMI_LOWERCASE_MALAY:
  200.         case INPUT_MODE_SMART_LOWERCASE_MALAY:
  201.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_malay_STRING_ID);
  202.             break;
  204.         case INPUT_MODE_MULTITAP_UPPERCASE_VIETNAMESE:
  205.         case INPUT_MODE_SMART_UPPERCASE_VIETNAMESE:
  206.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_VIETNAMESE_STRING_ID);
  207.             break;
  209.         case INPUT_MODE_MULTITAP_LOWERCASE_VIETNAMESE:
  210.         case INPUT_MODE_MMI_LOWERCASE_VIETNAMESE:
  211.         case INPUT_MODE_SMART_LOWERCASE_VIETNAMESE:
  212.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_vietnamese_STRING_ID);
  213.             break;
  215.         case INPUT_MODE_123:
  216.         case INPUT_MODE_MMI_NUMERIC:
  217.         case INPUT_MODE_123_SYMBOLS:
  218.             inputmode_string = (UI_string_type) get_string(WGUI_CATEGORY_123_STRING_ID);
  219.             break;
  221.         case INPUT_MODE_SMART_ARABIC:
  222.             /* inputmode_string=(UI_string_type)get_string(STR_INPUT_METHOD_ARABIC); */
  223.             break;
  225.         case INPUT_MODE_MMI_MULTITAP_BPMF:
  226.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  227.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  228.     #elif defined(__MMI_ZI__)
  229.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_BPMF_LOGO);
  230.     #else 
  231.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  232.     #endif 
  233.             break;
  235.         case INPUT_MODE_MMI_MULTITAP_PINYIN:
  236.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  237.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_PINYIN_IMG);
  238.     #elif defined(__MMI_ZI__)
  239.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_PINYIN_LOGO);
  240.     #else 
  241.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  242.     #endif 
  243.             break;
  245.         case INPUT_MODE_MMI_SM_STROKE:
  246.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  247.             inputbox_information_icon = get_image(WGUI_IME_SM_STROKE_IMG);
  248.     #elif defined(__MMI_ZI__)
  249.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_SM_STROKE_LOGO);
  250.     #else 
  251.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  252.     #endif 
  253.             break;
  255.         case INPUT_MODE_MMI_TR_STROKE:
  256.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  257.             inputbox_information_icon = get_image(WGUI_IME_TR_STROKE_IMG);
  258.     #elif defined(__MMI_ZI__)
  259.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_TR_STROKE_LOGO);
  260.     #else 
  261.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  262.     #endif 
  263.             break;
  265.         case INPUT_MODE_TR_MULTITAP_BOPOMO:
  266.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  267.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  268.     #elif defined(__MMI_ZI__)
  269.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_BPMF_LOGO);
  270.     #else 
  271.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  272.     #endif 
  273.             break;
  275.         case INPUT_MODE_SM_MULTITAP_PINYIN:
  276.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  277.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_PINYIN_IMG);
  278.     #elif defined(__MMI_ZI__)
  279.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_PINYIN_LOGO);
  280.     #else 
  281.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  282.     #endif 
  283.             break;
  285.         case INPUT_MODE_TR_STROKE:
  286.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  287.             inputbox_information_icon = get_image(WGUI_IME_TR_STROKE_IMG);
  288.     #elif defined(__MMI_ZI__)
  289.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_TR_STROKE_LOGO);
  290.     #else 
  291.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  292.     #endif 
  293.             break;
  295.         case INPUT_MODE_SM_STROKE:
  296.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  297.             inputbox_information_icon = get_image(WGUI_IME_SM_STROKE_IMG);
  298.     #elif defined(__MMI_ZI__)
  299.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_SM_STROKE_LOGO);
  300.     #else 
  301.             inputbox_information_icon = get_image(WGUI_IME_MULTITAP_BPMF_IMG);
  302.     #endif 
  303.             break;
  305.         case INPUT_MODE_TR_BOPOMO:
  306.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  307.             inputbox_information_icon = get_image(WGUI_IME_SMART_BPMF_IMG);
  308.     #elif defined(__MMI_ZI__)
  309.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_BPMF_LOGO);
  310.     #else 
  311.             inputbox_information_icon = get_image(WGUI_IME_SMART_BPMF_IMG);
  312.     #endif 
  313.             break;
  315.         case INPUT_MODE_SM_PINYIN:
  316.     #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-8
  317.             inputbox_information_icon = get_image(WGUI_IME_SMART_PINYIN_IMG);
  318.     #elif defined(__MMI_ZI__)
  319.             inputbox_information_icon = get_image(WGUI_ZI_EZITEXT_PINYIN_LOGO);
  320.     #else 
  321.             inputbox_information_icon = get_image(WGUI_IME_SMART_PINYIN_IMG);
  322.     #endif 
  323.             break;
  324.     }
  325.     if (NULL != inputmode_string)
  326.     {
  327.         set_softkey_label(inputmode_string, MMI_CENTER_SOFTKEY);
  328.     }
  329.     if (NULL != inputbox_information_icon)
  330.     {
  331.         set_softkey_icon(inputbox_information_icon, MMI_CENTER_SOFTKEY);
  332.     }
  333.     redraw_softkey(MMI_CENTER_SOFTKEY);
  334. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  335. }
  338. /*****************************************************************************
  339.  * FUNCTION
  340.  *  mmi_pen_editor_exit_screen
  341.  * DESCRIPTION
  342.  *  Common function for handwriting when exiting screen. This is used in UI_common_screen_exit.
  343.  * PARAMETERS
  344.  *  void
  345.  * RETURNS
  346.  *  void
  347.  *****************************************************************************/
  348. void mmi_pen_editor_exit_screen(void)
  349. {
  350.     /*----------------------------------------------------------------*/
  351.     /* Local Variables                                                */
  352.     /*----------------------------------------------------------------*/
  354.     /*----------------------------------------------------------------*/
  355.     /* Code Body                                                      */
  356.     /*----------------------------------------------------------------*/
  357.     /* W06.04 Set gPenEditorGDIHandler to NULL when exiting screen */
  358.     gPenEditorGDIHandler = NULL;
  359.     gPenEditorListMenuHeight = 0;
  360.     if (gPenEditorStrokeGDIBuffer)
  361.     {
  362.         mmi_frm_scrmem_free((void*)gPenEditorStrokeGDIBuffer);
  363.     }
  364.     gPenEditorStrokeGDIBuffer = NULL;
  365. }
  367. /* W06.09 Touch Screen With Keypad V1 */
  370. /*****************************************************************************
  371.  * FUNCTION
  372.  *  mmi_pen_editor_bpmf_pinyin_key_down_handler
  373.  * DESCRIPTION
  374.  *  The handler of key down(number keys) in Multitap BPMF/PinYin
  375.  * PARAMETERS
  376.  *  key     [IN]        The key index
  377.  * RETURNS
  378.  *  void
  379.  *****************************************************************************/
  380. void mmi_pen_editor_bpmf_pinyin_key_down_handler(S32 key)
  381. {
  382. //Jerry add on 2007-1-12 start
  383. #if defined(__MMI_TOUCH_SCREEN_WITH_NUMERIC_KEY__)
  384. if(gPenEditorFirstStroke)
  385. {
  386. #endif
  387. //Jerry add on 2007-1-12 end
  389.     /*----------------------------------------------------------------*/
  390.     /* Local Variables                                                */
  391.     /*----------------------------------------------------------------*/
  393.     /*----------------------------------------------------------------*/
  394.     /* Code Body                                                      */
  395.     /*----------------------------------------------------------------*/
  396.     mmi_pen_editor_cancel_handwriting();
  397.     if (gPenEditorSelectCandidate && (0 == gPenEditorVKText.TextLength))
  398.     {
  399.         gui_cancel_timer(mmi_pen_editor_confirm_selection);
  400.         mmi_pen_editor_confirm_selection();
  401.     }
  403.     if (key < 0 || key > MAX_MULTITAPS - 1)
  404.     {
  405.         return;
  406.     }
  408.     if (MMI_virtual_keyboard.lang_type == GUI_VIRTUAL_KEYBOARD_CHINESE_SYMBOL)
  409.     {
  410.         mmi_pen_editor_vk_symbol_picker();
  411.     }
  412.     if (MMI_virtual_keyboard.lang_type == GUI_VIRTUAL_KEYBOARD_TRAY)
  413.     {
  414.         mmi_pen_editor_vk_show();
  415.     }
  416.     if (key != g_pen_editor_active_multitap_index)
  417.     {
  418.         if (g_pen_editor_active_multitap_index >= 0)
  419.         {
  420.             gui_multitap_input_complete(&
  421.                                         (g_pen_editor_bpmf_pinyin_active_multitap[g_pen_editor_active_multitap_index]));
  422.         }
  423.         g_pen_editor_active_multitap_index = key;
  424.     }
  426.     gui_change_multitap_input_state(&(g_pen_editor_bpmf_pinyin_active_multitap[g_pen_editor_active_multitap_index]));
  428. //Jerry add on 2007-1-12 start
  429. #if defined(__MMI_TOUCH_SCREEN_WITH_NUMERIC_KEY__)
  430. }
  431. #endif
  432. //Jerry add on 2007-1-12 end
  433. }
  436. /*****************************************************************************
  437.  * FUNCTION
  438.  *  mmi_pen_editor_bpmf_pinyin_key_up_handler
  439.  * DESCRIPTION
  440.  *  The handler of key up(number keys) in Multitap BPMF/PinYin
  441.  * PARAMETERS
  442.  *  key     [IN]        The key index
  443.  * RETURNS
  444.  *  void
  445.  *****************************************************************************/
  446. void mmi_pen_editor_bpmf_pinyin_key_up_handler(S32 key)
  447. {
  448.     /*----------------------------------------------------------------*/
  449.     /* Local Variables                                                */
  450.     /*----------------------------------------------------------------*/
  452.     /*----------------------------------------------------------------*/
  453.     /* Code Body                                                      */
  454.     /*----------------------------------------------------------------*/
  455.     UI_UNUSED_PARAMETER(key);
  456.     gui_start_timer(MMI_MULTITAP_TIMEOUT, mmi_pen_editor_bpmf_pinyin_disable_active_multitap);
  457. }
  460. /*****************************************************************************
  461.  * FUNCTION
  462.  *  mmi_pen_editor_bpmf_pinyin_disable_active_multitap
  463.  * DESCRIPTION
  464.  *  Complete Multitap input for Multitap BPMF/PinYin
  465.  * PARAMETERS
  466.  *  void
  467.  * RETURNS
  468.  *  void
  469.  *****************************************************************************/
  470. void mmi_pen_editor_bpmf_pinyin_disable_active_multitap(void)
  471. {
  472.     /*----------------------------------------------------------------*/
  473.     /* Local Variables                                                */
  474.     /*----------------------------------------------------------------*/
  476.     /*----------------------------------------------------------------*/
  477.     /* Code Body                                                      */
  478.     /*----------------------------------------------------------------*/
  479.     if (g_pen_editor_active_multitap_index < 0)
  480.     {
  481.         return;
  482.     }
  483.     gui_multitap_input_complete(&g_pen_editor_bpmf_pinyin_active_multitap[g_pen_editor_active_multitap_index]);
  484.     g_pen_editor_active_multitap_index = -1;
  485. }
  488. /*****************************************************************************
  489.  * FUNCTION
  490.  *  mmi_pen_editor_bpmf_pinyin_multitap_input
  491.  * DESCRIPTION
  492.  *  Handle the multitap input character c in multitap BPMF/PinYin
  493.  * PARAMETERS
  494.  *  c       [IN]        The multitap input character
  495.  * RETURNS
  496.  *  void
  497.  *****************************************************************************/
  498. void mmi_pen_editor_bpmf_pinyin_multitap_input(UI_character_type c)
  499. {
  500.     /*----------------------------------------------------------------*/
  501.     /* Local Variables                                                */
  502.     /*----------------------------------------------------------------*/
  504.     /*----------------------------------------------------------------*/
  505.     /* Code Body                                                      */
  506.     /*----------------------------------------------------------------*/
  507.     if (g_pen_editor_bpmf_pinyin_previous_valid_character)
  508.     {
  509.         mmi_pen_editor_vk_delete_character(&gPenEditorVKText);
  510.     }
  511.     if (mmi_pen_editor_vk_insert_character(&gPenEditorVKText, c))
  512.     {
  513.         /* Check the input is valid or not */
  514.         if (mmi_pen_editor_get_candidates_by_vk())
  515.         {
  516.             switch (gPenEditorInputBoxType)
  517.             {
  518.                 case PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX:
  519.                 case PEN_EDITOR_MULTILINE_INPUT_BOX:
  520.                 case PEN_EDITOR_DICT_MULTILINE_INPUT_BOX:
  521.                     wgui_inputbox_RSK_label_clear = 1;
  522.                     break;
  524.                 case PEN_EDITOR_EMS_INPUT_BOX:
  525.                     category28_RSK_label_clear = 1;
  526.                     break;
  528.                 default:
  529.                     break;
  530.             }
  531.             /* Temp Solution for LSK Text Update */
  532.             /* W05.35 For LSK Text Issue */
  533.             if (gPenEditorVKText.TextLength == 1 && MMI_FALSE == gPenEditorSelectCandidate)
  534.             {
  535.                 mmi_pen_editor_store_LSK_Text();
  536.             }
  537.             mmi_pen_editor_set_left_soft_key_select();
  538.             set_left_softkey_function(mmi_pen_editor_left_soft_key_handler, KEY_EVENT_UP);
  539.             set_left_softkey_function(mmi_pen_editor_hold_confirm, KEY_EVENT_DOWN);
  540.             gPenEditorSelectCandidate = MMI_TRUE;
  541.             mmi_pen_editor_register_arrow_keys();
  542.             mmi_pen_editor_set_right_softkey(PEN_EDITOR_RSK_CLEAR);
  543.             g_pen_editor_bpmf_pinyin_previous_valid_character = c;
  544.         }
  545.         else
  546.         {
  547.             mmi_pen_editor_vk_delete_character(&gPenEditorVKText);
  548.             if (g_pen_editor_bpmf_pinyin_previous_valid_character)
  549.             {
  550.                 mmi_pen_editor_vk_insert_character(
  551.                     &gPenEditorVKText,
  552.                     g_pen_editor_bpmf_pinyin_previous_valid_character);
  553.             }
  554.         }
  555.     }
  556.     wgui_set_virtual_keyboard_display_area((U8*) gPenEditorVKText.VKText, MMI_TRUE);
  557. }
  560. /*****************************************************************************
  561.  * FUNCTION
  562.  *  mmi_pen_editor_bpmf_pinyin_multitap_input_complete
  563.  * DESCRIPTION
  564.  *  Set g_pen_editor_bpmf_pinyin_previous_valid_character to 0 when conmpleting multitap input
  565.  * PARAMETERS
  566.  *  void
  567.  * RETURNS
  568.  *  void
  569.  *****************************************************************************/
  570. void mmi_pen_editor_bpmf_pinyin_multitap_input_complete(void)
  571. {
  572.     /*----------------------------------------------------------------*/
  573.     /* Local Variables                                                */
  574.     /*----------------------------------------------------------------*/
  576.     /*----------------------------------------------------------------*/
  577.     /* Code Body                                                      */
  578.     /*----------------------------------------------------------------*/
  579.     g_pen_editor_bpmf_pinyin_previous_valid_character = 0;
  580. }
  583. /*****************************************************************************
  584.  * FUNCTION
  585.  *  mmi_pen_editor_bpmf_pinyin_register_multitap_function
  586.  * DESCRIPTION
  587.  *  Register key functions for Multitap BPMF/PinYin and set Multitap BPMF/Pinyin functions to g_pen_editor_bpmf_pinyin_active_multitap
  588.  * PARAMETERS
  589.  *  void
  590.  * RETURNS
  591.  *  void
  592.  *****************************************************************************/
  593. void mmi_pen_editor_bpmf_pinyin_register_multitap_function(void)
  594. {
  595.     /*----------------------------------------------------------------*/
  596.     /* Local Variables                                                */
  597.     /*----------------------------------------------------------------*/
  598.     int i = 0;
  600.     /*----------------------------------------------------------------*/
  601.     /* Code Body                                                      */
  602.     /*----------------------------------------------------------------*/
  603.     register_MMI_key_input_handler();
  604.     register_key_up_handler(mmi_pen_editor_bpmf_pinyin_key_up_handler);
  605.     register_key_down_handler(mmi_pen_editor_bpmf_pinyin_key_down_handler);
  606.     for (i = 0; i < MAX_MULTITAPS; i++)
  607.     {
  608.         gui_set_multitap_input_callbacks(
  609.             &g_pen_editor_bpmf_pinyin_active_multitap[i],
  610.             mmi_pen_editor_bpmf_pinyin_multitap_input,
  611.             mmi_pen_editor_bpmf_pinyin_multitap_input_complete);
  612.     }
  613. }
  616. /*****************************************************************************
  617.  * FUNCTION
  618.  *  mmi_pen_editor_bpmf_pinyin_create_multitap
  619.  * DESCRIPTION
  620.  *  Create multitap control according to input_mode
  621.  * PARAMETERS
  622.  *  input_mode      [IN]        Its value should be INPUT_MODE_TR_MULTITAP_BOPOMO or INPUT_MODE_SM_MULTITAP_PINYIN
  623.  * RETURNS
  624.  *  void
  625.  *****************************************************************************/
  626. void mmi_pen_editor_bpmf_pinyin_create_multitap(U8 input_mode)
  627. {
  628.     /*----------------------------------------------------------------*/
  629.     /* Local Variables                                                */
  630.     /*----------------------------------------------------------------*/
  631.     S32 i, width;
  632.     UI_string_type s;
  634.     /*----------------------------------------------------------------*/
  635.     /* Code Body                                                      */
  636.     /*----------------------------------------------------------------*/
  637.     width = MMI_multitap_width; /* Width needs to be auto-calculated   */
  638.     g_pen_editor_active_multitap_index = -1;
  639.     for (i = 0; i < MAX_MULTITAPS; i++)
  640.     {
  641.         if (INPUT_MODE_TR_MULTITAP_BOPOMO == MMI_current_input_mode)
  642.         {
  643.             s = get_bpmf_multitap_string(i);
  644.             gui_create_multitap_input(
  645.                 &g_pen_editor_bpmf_pinyin_active_multitap[i],
  646.                 MMI_multitap_x,
  647.                 MMI_multitap_y,
  648.                 width,
  649.                 MMI_multitap_height,
  650.                 s);
  651.         }
  652.         else if (INPUT_MODE_SM_MULTITAP_PINYIN == MMI_current_input_mode)
  653.         {
  654.             s = (UI_string_type) numberless_lowercase_multitap_strings[i];
  655.             gui_create_multitap_input(
  656.                 &g_pen_editor_bpmf_pinyin_active_multitap[i],
  657.                 MMI_multitap_x,
  658.                 MMI_multitap_y,
  659.                 width,
  660.                 MMI_multitap_height,
  661.                 s);
  662.         }
  663.         else
  664.         {
  665.             MMI_ASSERT(0);
  666.         }
  667.     }
  668. }
  671. /*****************************************************************************
  672.  * FUNCTION
  673.  *  mmi_pen_editor_hold_confirm
  674.  * DESCRIPTION
  675.  *  Do not confirm the selection directly when the candidate box is on
  676.  * PARAMETERS
  677.  *  void
  678.  * RETURNS
  679.  *  void
  680.  *****************************************************************************/
  681. void mmi_pen_editor_hold_confirm(void)
  682. {
  683.     /*----------------------------------------------------------------*/
  684.     /* Local Variables                                                */
  685.     /*----------------------------------------------------------------*/
  687.     /*----------------------------------------------------------------*/
  688.     /* Code Body                                                      */
  689.     /*----------------------------------------------------------------*/
  690.     if (gPenEditorSelectCandidate)
  691.     {
  692.         gui_cancel_timer(mmi_pen_editor_confirm_selection);
  693.         g_pen_editor_hold_confirm = MMI_TRUE;
  694.     }
  695. }
  698. /*****************************************************************************
  699.  * FUNCTION
  700.  *  mmi_pen_editor_smart_latin_register_key_function
  701.  * DESCRIPTION
  702.  *  Register key functions for Smart Latin
  703.  * PARAMETERS
  704.  *  void
  705.  * RETURNS
  706.  *  void
  707.  *****************************************************************************/
  708. void mmi_pen_editor_smart_latin_register_key_function(void)
  709. {
  710.     /*----------------------------------------------------------------*/
  711.     /* Local Variables                                                */
  712.     /*----------------------------------------------------------------*/
  714.     /*----------------------------------------------------------------*/
  715.     /* Code Body                                                      */
  716.     /*----------------------------------------------------------------*/
  717.     register_MMI_key_input_handler();
  718.     register_key_up_handler(mmi_pen_editor_smart_latin_key_up_handler);
  719.     register_key_down_handler(mmi_pen_editor_smart_latin_key_down_handler);
  720.     ClearKeyHandler(KEY_0, KEY_REPEAT);
  721.     ClearKeyHandler(KEY_1, KEY_REPEAT);
  722.     ClearKeyHandler(KEY_2, KEY_REPEAT);
  723.     ClearKeyHandler(KEY_3, KEY_REPEAT);
  724.     ClearKeyHandler(KEY_4, KEY_REPEAT);
  725.     ClearKeyHandler(KEY_5, KEY_REPEAT);
  726.     ClearKeyHandler(KEY_6, KEY_REPEAT);
  727.     ClearKeyHandler(KEY_7, KEY_REPEAT);
  728.     ClearKeyHandler(KEY_8, KEY_REPEAT);
  729.     ClearKeyHandler(KEY_9, KEY_REPEAT);
  730. }
  733. /*****************************************************************************
  734.  * FUNCTION
  735.  *  mmi_pen_editor_smart_latin_key_down_handler
  736.  * DESCRIPTION
  737.  *  The handler of key down(number keys) in Smart Latin
  738.  * PARAMETERS
  739.  *  key     [IN]        The key index
  740.  * RETURNS
  741.  *  void
  742.  *****************************************************************************/
  743. void mmi_pen_editor_smart_latin_key_down_handler(S32 key)
  744. {
  745.     /*----------------------------------------------------------------*/
  746.     /* Local Variables                                                */
  747.     /*----------------------------------------------------------------*/
  748.     UI_character_type candidate_buffer[PEN_EDITOR_MAX_KEY_BUFFER_SIZE];
  749.     U32 candidatelength = 0;
  751.     /*----------------------------------------------------------------*/
  752.     /* Code Body                                                      */
  753.     /*----------------------------------------------------------------*/
  754.     if (!mmi_pen_editor_get_remaining_length())
  755.     {
  756.         return;
  757.     }
  758.     gdi_layer_lock_frame_buffer();
  759.     if (gPenEditorSelectCandidate && !g_pen_editor_key_sequence.KeyLength)
  760.     {
  761.         gui_cancel_timer(mmi_pen_editor_confirm_selection);
  762.         mmi_pen_editor_confirm_selection();
  763.     }
  765.     if (KEY_0 == key)
  766.     {
  767.         if (g_pen_editor_smart_latin_pre_candidate_length)
  768.         {
  769.             mmi_pen_editor_smart_latin_confirm_select();
  770.             mmi_pen_editor_set_left_soft_key();
  771.         }
  772.         mmi_pen_editor_input_character(0x20, MMI_FALSE);
  773.     }
  774.     else if (mmi_pen_editor_add_key_sequence(&g_pen_editor_key_sequence, key))
  775.     {
  776.         candidatelength = mmi_ime_smart_latin_get_candidates_by_key_sequence(
  777.                             g_pen_editor_key_sequence.KeySequence,
  778.                             g_pen_editor_key_sequence.KeyLength,
  779.                             candidate_buffer);
  780.         if (candidatelength)
  781.         {
  782.             if (candidatelength < g_pen_editor_key_sequence.KeyLength)
  783.             {
  784.                 mmi_pen_editor_smart_latin_confirm_select();
  785.                 mmi_pen_editor_add_key_sequence(&g_pen_editor_key_sequence, key);
  786.                 candidatelength = mmi_ime_smart_latin_get_candidates_by_key_sequence(
  787.                                     g_pen_editor_key_sequence.KeySequence,
  788.                                     g_pen_editor_key_sequence.KeyLength,
  789.                                     candidate_buffer);
  790.             }
  791.             mmi_pen_editor_smart_latin_replace_candidate(candidate_buffer, candidatelength);
  792.             if (g_pen_editor_key_sequence.KeyLength == 1 && MMI_FALSE == gPenEditorSelectCandidate)
  793.             {
  794.                 mmi_pen_editor_store_LSK_Text();
  795.             }
  796.             mmi_pen_editor_set_left_soft_key_select();
  797.             set_left_softkey_function(mmi_pen_editor_left_soft_key_handler, KEY_EVENT_UP);
  798.             set_left_softkey_function(mmi_pen_editor_hold_confirm, KEY_EVENT_DOWN);
  799.             mmi_pen_editor_smart_latin_register_arrow_keys();
  800.         }
  801.         else
  802.         {
  803.             mmi_pen_editor_del_key_sequence(&g_pen_editor_key_sequence);
  804.         }
  805.     }
  806.     gdi_layer_unlock_frame_buffer();
  807.     gdi_lcd_repaint_all();
  808. }
  811. /*****************************************************************************
  812.  * FUNCTION
  813.  *  mmi_pen_editor_smart_latin_key_up_handler
  814.  * DESCRIPTION
  815.  *  The handler of key up(number keys) in Smart Latin
  816.  * PARAMETERS
  817.  *  key     [IN]        The key index
  818.  * RETURNS
  819.  *  void
  820.  *****************************************************************************/
  821. void mmi_pen_editor_smart_latin_key_up_handler(S32 key)
  822. {
  823.     /*----------------------------------------------------------------*/
  824.     /* Local Variables                                                */
  825.     /*----------------------------------------------------------------*/
  827.     /*----------------------------------------------------------------*/
  828.     /* Code Body                                                      */
  829.     /*----------------------------------------------------------------*/
  830.     UI_UNUSED_PARAMETER(key);
  831. }
  834. /*****************************************************************************
  835.  * FUNCTION
  836.  *  mmi_pen_editor_smart_latin_highlight_candidate
  837.  * DESCRIPTION
  838.  *  Unhighlight the candidate in Smart Latin
  839.  * PARAMETERS
  840.  *  candidate_length        [IN]        The length of the highlighted candidate
  841.  * RETURNS
  842.  *  void
  843.  *****************************************************************************/
  844. void mmi_pen_editor_smart_latin_highlight_candidate(U32 candidate_length)
  845. {
  846.     /*----------------------------------------------------------------*/
  847.     /* Local Variables                                                */
  848.     /*----------------------------------------------------------------*/
  849.     S32 count = 0;
  851.     /*----------------------------------------------------------------*/
  852.     /* Code Body                                                      */
  853.     /*----------------------------------------------------------------*/
  854.     switch (gPenEditorInputBoxType)
  855.     {
  856.         case PEN_EDITOR_MULTILINE_INPUT_BOX:
  857.         case PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX:
  858.         case PEN_EDITOR_DICT_MULTILINE_INPUT_BOX:
  859.             count = gui_multi_line_input_box_highlight_cursor_number(&MMI_multiline_inputbox, candidate_length);
  860.             break;
  862.         case PEN_EDITOR_EMS_INPUT_BOX:
  863.             count = gui_EMS_input_box_highlight_cursor_number(&MMI_EMS_inputbox, candidate_length);
  864.             gui_show_EMS_input_box(&MMI_EMS_inputbox);
  865.             break;
  867.         case PEN_EDITOR_SINGLE_LINE_INPU_BOX:
  868.             count = gui_single_line_input_box_highlight_cursor_number(&MMI_singleline_inputbox, candidate_length);
  869.             break;
  871.         case PEN_EDITOR_INLINE_TEXT:
  872.             count = gui_single_line_input_box_highlight_cursor_number(&MMI_inline_singleline_inputbox, candidate_length);
  873.             break;
  875.         default:
  876.             break;
  877.     }
  878. }
  881. /*****************************************************************************
  882.  * FUNCTION
  883.  *  mmi_pen_editor_smart_latin_unhighlight_candidate
  884.  * DESCRIPTION
  885.  *  
  886.  * PARAMETERS
  887.  *  draw        [IN]        MMI_TRUE : Redraw the input box
  888.  *                          MMI_FALSE : Do not redraw the input box
  889.  * RETURNS
  890.  *  void
  891.  *****************************************************************************/
  892. void mmi_pen_editor_smart_latin_unhighlight_candidate(MMI_BOOL draw)
  893. {
  894.     /*----------------------------------------------------------------*/
  895.     /* Local Variables                                                */
  896.     /*----------------------------------------------------------------*/
  898.     /*----------------------------------------------------------------*/
  899.     /* Code Body                                                      */
  900.     /*----------------------------------------------------------------*/
  901.     switch (gPenEditorInputBoxType)
  902.     {
  903.         case PEN_EDITOR_MULTILINE_INPUT_BOX:
  904.         case PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX:
  905.         case PEN_EDITOR_DICT_MULTILINE_INPUT_BOX:
  906.             MMI_multiline_inputbox.flags &= ~UI_MULTI_LINE_INPUT_BOX_WORD_HIGHLIGHT;
  907.             if (draw)
  908.             {
  909.                 gui_show_multi_line_input_box(&MMI_multiline_inputbox);
  910.             }
  911.             break;
  913.         case PEN_EDITOR_EMS_INPUT_BOX:
  914.             MMI_EMS_inputbox.flags &= ~UI_EMS_INPUT_BOX_WORD_HIGHLIGHT;
  915.             if (draw)
  916.             {
  917.                 gui_show_EMS_input_box(&MMI_EMS_inputbox);
  918.             }
  919.             break;
  921.         case PEN_EDITOR_SINGLE_LINE_INPU_BOX:
  922.             MMI_singleline_inputbox.flags &= ~UI_SINGLE_LINE_INPUT_BOX_WORD_HIGHLIGHT;
  923.             if (draw)
  924.             {
  925.                 gui_show_single_line_input_box(&MMI_singleline_inputbox);
  926.             }
  927.             break;
  929.         case PEN_EDITOR_INLINE_TEXT:
  930.             MMI_inline_singleline_inputbox.flags &= ~UI_SINGLE_LINE_INPUT_BOX_WORD_HIGHLIGHT;
  931.             if (draw)
  932.             {
  933.                 gui_show_single_line_input_box(&MMI_inline_singleline_inputbox);
  934.             }
  935.             break;
  937.         default:
  938.             break;
  939.     }
  940. }
  943. /*****************************************************************************
  944.  * FUNCTION
  945.  *  mmi_pen_editor_chinese_stroke_register_key_function
  946.  * DESCRIPTION
  947.  *  Register key functions for Chinese Stroke
  948.  * PARAMETERS
  949.  *  void
  950.  * RETURNS
  951.  *  void
  952.  *****************************************************************************/
  953. void mmi_pen_editor_chinese_stroke_register_key_function(void)
  954. {
  955.     /*----------------------------------------------------------------*/
  956.     /* Local Variables                                                */
  957.     /*----------------------------------------------------------------*/
  959.     /*----------------------------------------------------------------*/
  960.     /* Code Body                                                      */
  961.     /*----------------------------------------------------------------*/
  962.     register_MMI_key_input_handler();
  963.     register_key_up_handler(mmi_pen_editor_chinese_stroke_key_up_handler);
  964.     register_key_down_handler(mmi_pen_editor_chinese_stroke_key_down_handler);
  965.     ClearKeyHandler(KEY_0, KEY_REPEAT);
  966.     ClearKeyHandler(KEY_1, KEY_REPEAT);
  967.     ClearKeyHandler(KEY_2, KEY_REPEAT);
  968.     ClearKeyHandler(KEY_3, KEY_REPEAT);
  969.     ClearKeyHandler(KEY_4, KEY_REPEAT);
  970.     ClearKeyHandler(KEY_5, KEY_REPEAT);
  971.     ClearKeyHandler(KEY_6, KEY_REPEAT);
  972.     ClearKeyHandler(KEY_7, KEY_REPEAT);
  973.     ClearKeyHandler(KEY_8, KEY_REPEAT);
  974.     ClearKeyHandler(KEY_9, KEY_REPEAT);
  975. }
  978. /*****************************************************************************
  979.  * FUNCTION
  980.  *  mmi_pen_editor_chinese_stroke_key_down_handler
  981.  * DESCRIPTION
  982.  *  The handler of key down(number keys) in Chinese Stroke
  983.  * PARAMETERS
  984.  *  key     [IN]        The key index
  985.  * RETURNS
  986.  *  void
  987.  *****************************************************************************/
  988. void mmi_pen_editor_chinese_stroke_key_down_handler(S32 key)
  989. {
  990. //Jerry add on 2007-1-12 start
  991. #if defined(__MMI_TOUCH_SCREEN_WITH_NUMERIC_KEY__)
  992. if(gPenEditorFirstStroke)
  993. {
  994. #endif
  995. //Jerry add on 2007-1-12 end
  997.     /*----------------------------------------------------------------*/
  998.     /* Local Variables                                                */
  999.     /*----------------------------------------------------------------*/
  1001.     /*----------------------------------------------------------------*/
  1002.     /* Code Body                                                      */
  1003.     /*----------------------------------------------------------------*/
  1004.     gdi_layer_lock_frame_buffer();
  1005.     mmi_pen_editor_cancel_handwriting();
  1006.     if (gPenEditorSelectCandidate && (g_pen_editor_composition_state.candidate_state == PEN_EDITOR_CANDIDATE_OFF))
  1007.     {
  1008.         gui_cancel_timer(mmi_pen_editor_confirm_selection);
  1009.         mmi_pen_editor_confirm_selection();
  1010.     }
  1012.     if (KEY_0 == key)
  1013.     {
  1014.     }
  1015.     else 
  1016. #if defined(__MMI_T9__) || defined(__MMI_CSTAR__)     //KP Jerry add "__MMI_CSTAR__" on 2007-3-21
  1017.     if (KEY_7 <= key && KEY_9 >= key)
  1018.     {
  1019.     }
  1020.     else 
  1021. #endif
  1022.     if (mmi_pen_editor_add_key_sequence(&g_pen_editor_key_sequence, key))
  1023.     {
  1024.         if (mmi_pen_editor_chinese_stroke_get_candidates_by_key_sequence(&g_pen_editor_key_sequence))
  1025.         {
  1026.             switch (gPenEditorInputBoxType)
  1027.             {
  1028.                 case PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX:
  1029.                 case PEN_EDITOR_MULTILINE_INPUT_BOX:
  1030.                 case PEN_EDITOR_DICT_MULTILINE_INPUT_BOX:
  1031.                     wgui_inputbox_RSK_label_clear = 1;
  1032.                     break;
  1034.                 case PEN_EDITOR_EMS_INPUT_BOX:
  1035.                     category28_RSK_label_clear = 1;
  1036.                     break;
  1038.                 default:
  1039.                     break;
  1040.             }
  1041.             /* Temp Solution for LSK Text Update */
  1042.             /* W05.35 For LSK Text Issue */
  1043.             if (g_pen_editor_key_sequence.KeyLength == 1 && MMI_FALSE == gPenEditorSelectCandidate)
  1044.             {
  1045.                 mmi_pen_editor_store_LSK_Text();
  1046.             }
  1047.             mmi_pen_editor_set_left_soft_key_select();
  1048.             set_left_softkey_function(mmi_pen_editor_left_soft_key_handler, KEY_EVENT_UP);
  1049.             set_left_softkey_function(mmi_pen_editor_hold_confirm, KEY_EVENT_DOWN);
  1050.             gPenEditorSelectCandidate = MMI_TRUE;
  1051.             mmi_pen_editor_register_arrow_keys();
  1052.             mmi_pen_editor_set_right_softkey(PEN_EDITOR_RSK_CLEAR);
  1053.         }
  1054.         else
  1055.         {
  1056.             mmi_pen_editor_del_key_sequence(&g_pen_editor_key_sequence);
  1057.         }
  1058.     }
  1059.     gdi_layer_unlock_frame_buffer();
  1060.     gdi_lcd_repaint_all();
  1061.     mmi_pen_editor_change_handwriting_area();
  1063. //Jerry add on 2007-1-12 start
  1064. #if defined(__MMI_TOUCH_SCREEN_WITH_NUMERIC_KEY__)
  1065. }
  1066. #endif
  1067. //Jerry add on 2007-1-12 end
  1068. }
  1071. /*****************************************************************************
  1072.  * FUNCTION
  1073.  *  mmi_pen_editor_chinese_stroke_key_up_handler
  1074.  * DESCRIPTION
  1075.  *  The handler of key up(number keys) in Chinese Stroke
  1076.  * PARAMETERS
  1077.  *  key     [IN]        The key index
  1078.  * RETURNS
  1079.  *  void
  1080.  *****************************************************************************/
  1081. void mmi_pen_editor_chinese_stroke_key_up_handler(S32 key)
  1082. {
  1083.     /*----------------------------------------------------------------*/
  1084.     /* Local Variables                                                */
  1085.     /*----------------------------------------------------------------*/
  1087.     /*----------------------------------------------------------------*/
  1088.     /* Code Body                                                      */
  1089.     /*----------------------------------------------------------------*/
  1090.     UI_UNUSED_PARAMETER(key);
  1091. }
  1094. /*****************************************************************************
  1095.  * FUNCTION
  1096.  *  mmi_pen_editor_get_remaining_length
  1097.  * DESCRIPTION
  1098.  *  To know how many characters could be inserted in current state
  1099.  * PARAMETERS
  1100.  *  void
  1101.  * RETURNS
  1102.  *  The number of the characters could be inserted
  1103.  *****************************************************************************/
  1104. S32 mmi_pen_editor_get_remaining_length(void)
  1105. {
  1106.     /*----------------------------------------------------------------*/
  1107.     /* Local Variables                                                */
  1108.     /*----------------------------------------------------------------*/
  1110.     /*----------------------------------------------------------------*/
  1111.     /* Code Body                                                      */
  1112.     /*----------------------------------------------------------------*/
  1113.     switch (gPenEditorInputBoxType)
  1114.     {
  1115.         case PEN_EDITOR_MULTILINE_INPUT_BOX:
  1116.         case PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX:
  1117.         case PEN_EDITOR_DICT_MULTILINE_INPUT_BOX:
  1118.             return (gui_multi_line_input_box_get_remaining_length(&MMI_multiline_inputbox));
  1120.         case PEN_EDITOR_EMS_INPUT_BOX:
  1121.             return (EMS_get_remaining_length(MMI_EMS_inputbox.data));
  1123.         case PEN_EDITOR_SINGLE_LINE_INPU_BOX:
  1124.         case PEN_EDITOR_QUICK_SEARCH_SINGLE_LINE_INPU_BOX:
  1125.             return (gui_single_line_input_box_get_remaining_length(&MMI_singleline_inputbox));
  1127.         case PEN_EDITOR_INLINE_TEXT:
  1128.             return (gui_single_line_input_box_get_remaining_length(&MMI_inline_singleline_inputbox));
  1130.         case PEN_EDITOR_DATE:
  1131.         case PEN_EDITOR_IP4:
  1132.         case PEN_EDITOR_TIME:
  1133.         case PEN_EDITOR_TIME_PERIOD:
  1134.             return 0;
  1136.         default:
  1137.             MMI_ASSERT(0);
  1138.     }
  1139.     return 0;
  1140. }
  1143. /*****************************************************************************
  1144.  * FUNCTION
  1145.  *  mmi_pen_editor_smart_latin_confirm_select
  1146.  * DESCRIPTION
  1147.  *  Confirm the selection in Smart Latin
  1148.  * PARAMETERS
  1149.  *  void
  1150.  * RETURNS
  1151.  *  void
  1152.  *****************************************************************************/
  1153. void mmi_pen_editor_smart_latin_confirm_select(void)
  1154. {
  1155.     /*----------------------------------------------------------------*/
  1156.     /* Local Variables                                                */
  1157.     /*----------------------------------------------------------------*/
  1159.     /*----------------------------------------------------------------*/
  1160.     /* Code Body                                                      */
  1161.     /*----------------------------------------------------------------*/
  1162.     g_pen_editor_smart_latin_pre_candidate_length = 0;
  1163.     g_pen_editor_smart_latin_candidate_index = 0;
  1164.     mmi_pen_editor_smart_latin_unhighlight_candidate(MMI_TRUE);
  1165.     mmi_pen_editor_reset_key_sequence(&g_pen_editor_key_sequence);
  1166. }
  1169. /*****************************************************************************
  1170.  * FUNCTION
  1171.  *  mmi_pen_editor_smart_latin_replace_candidate
  1172.  * DESCRIPTION
  1173.  *  Replace the candiate in the input box the candidate is changed
  1174.  * PARAMETERS
  1175.  *  candidate_buffer        [OUT]         The new candidate
  1176.  *  candidatelength         [IN]          The length of the candidate
  1177.  * RETURNS
  1178.  *  void
  1179.  *****************************************************************************/
  1180. void mmi_pen_editor_smart_latin_replace_candidate(UI_character_type *candidate_buffer, S32 candidatelength)
  1181. {
  1182.     /*----------------------------------------------------------------*/
  1183.     /* Local Variables                                                */
  1184.     /*----------------------------------------------------------------*/
  1185.     U32 i = 0;
  1187.     /*----------------------------------------------------------------*/
  1188.     /* Code Body                                                      */
  1189.     /*----------------------------------------------------------------*/
  1190.     if (g_pen_editor_smart_latin_pre_candidate_length)
  1191.     {
  1192.         for (i = 0; i < g_pen_editor_smart_latin_pre_candidate_length; i++)
  1193.         {
  1194.             mmi_pen_editor_backspace();
  1195.         }
  1196.     }
  1197.     g_pen_editor_smart_latin_pre_candidate_length = candidatelength;
  1198.     for (i = 0; i < g_pen_editor_smart_latin_pre_candidate_length; i++)
  1199.     {
  1200.         mmi_pen_editor_input_character(candidate_buffer[i], MMI_FALSE);
  1201.     }
  1202.     mmi_pen_editor_smart_latin_highlight_candidate(g_pen_editor_smart_latin_pre_candidate_length);
  1203.     mmi_pen_editor_set_right_softkey(PEN_EDITOR_RSK_CLEAR);
  1204. }
  1207. /*****************************************************************************
  1208.  * FUNCTION
  1209.  *  mmi_pen_editor_smart_bpmf_pinyin_register_key_function
  1210.  * DESCRIPTION
  1211.  *  Register key functions for Smart BPMF/PinYin
  1212.  * PARAMETERS
  1213.  *  void
  1214.  * RETURNS
  1215.  *  void
  1216.  *****************************************************************************/
  1217. void mmi_pen_editor_smart_bpmf_pinyin_register_key_function(void)
  1218. {
  1219.     /*----------------------------------------------------------------*/
  1220.     /* Local Variables                                                */
  1221.     /*----------------------------------------------------------------*/
  1223.     /*----------------------------------------------------------------*/
  1224.     /* Code Body                                                      */
  1225.     /*----------------------------------------------------------------*/
  1226.     register_MMI_key_input_handler();
  1227.     register_key_up_handler(mmi_pen_editor_smart_bpmf_pinyin_key_up_handler);
  1228.     register_key_down_handler(mmi_pen_editor_smart_bpmf_pinyin_key_down_handler);
  1229.     ClearKeyHandler(KEY_0, KEY_REPEAT);
  1230.     ClearKeyHandler(KEY_1, KEY_REPEAT);
  1231.     ClearKeyHandler(KEY_2, KEY_REPEAT);
  1232.     ClearKeyHandler(KEY_3, KEY_REPEAT);
  1233.     ClearKeyHandler(KEY_4, KEY_REPEAT);
  1234.     ClearKeyHandler(KEY_5, KEY_REPEAT);
  1235.     ClearKeyHandler(KEY_6, KEY_REPEAT);
  1236.     ClearKeyHandler(KEY_7, KEY_REPEAT);
  1237.     ClearKeyHandler(KEY_8, KEY_REPEAT);
  1238.     ClearKeyHandler(KEY_9, KEY_REPEAT);
  1239. }
  1242. /*****************************************************************************
  1243.  * FUNCTION
  1244.  *  mmi_pen_editor_smart_bpmf_pinyin_key_down_handler
  1245.  * DESCRIPTION
  1246.  *  The handler of key down(number keys) in Smart BPMF/PinYin
  1247.  * PARAMETERS
  1248.  *  key     [IN]        The key index
  1249.  * RETURNS
  1250.  *  void
  1251.  *****************************************************************************/
  1252. void mmi_pen_editor_smart_bpmf_pinyin_key_down_handler(S32 key)
  1253. {
  1254.     /*----------------------------------------------------------------*/
  1255.     /* Local Variables                                                */
  1256.     /*----------------------------------------------------------------*/
  1258.     /*----------------------------------------------------------------*/
  1259.     /* Code Body                                                      */
  1260.     /*----------------------------------------------------------------*/
  1261.     gdi_layer_lock_frame_buffer();
  1262.     mmi_pen_editor_cancel_handwriting();
  1263.     if (gPenEditorSelectCandidate && (g_pen_editor_composition_state.candidate_state == PEN_EDITOR_CANDIDATE_OFF))
  1264.     {
  1265.         gui_cancel_timer(mmi_pen_editor_confirm_selection);
  1266.         mmi_pen_editor_confirm_selection();
  1267.     }
  1268.     if (KEY_0 == key &&
  1269.         (g_pen_editor_composition_state.candidate_state == PEN_EDITOR_CANDIDATE_OFF) &&
  1270.         INPUT_MODE_SM_PINYIN == MMI_current_input_mode && !gPenEditorSelectCandidate)
  1271.     {
  1272.         mmi_pen_editor_input_character(0x20, MMI_FALSE);
  1273.     }
  1274.     else if (KEY_1 == key && INPUT_MODE_SM_PINYIN == MMI_current_input_mode)
  1275.     {
  1276.     }
  1277.     else if (mmi_pen_editor_add_key_sequence(&g_pen_editor_key_sequence, key))
  1278.     {
  1279.         if (mmi_pen_editor_smart_bpmf_pinyin_get_candidates_by_key_sequence(&g_pen_editor_key_sequence, MMI_TRUE))
  1280.         {
  1281.             switch (gPenEditorInputBoxType)
  1282.             {
  1283.                 case PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX:
  1284.                 case PEN_EDITOR_MULTILINE_INPUT_BOX:
  1285.                 case PEN_EDITOR_DICT_MULTILINE_INPUT_BOX:
  1286.                     wgui_inputbox_RSK_label_clear = 1;
  1287.                     break;
  1289.                 case PEN_EDITOR_EMS_INPUT_BOX:
  1290.                     category28_RSK_label_clear = 1;
  1291.                     break;
  1293.                 default:
  1294.                     break;
  1295.             }
  1296.             /* Temp Solution for LSK Text Update */
  1297.             /* W05.35 For LSK Text Issue */
  1298.             if (g_pen_editor_key_sequence.KeyLength == 1 && MMI_FALSE == gPenEditorSelectCandidate)
  1299.             {
  1300.                 mmi_pen_editor_store_LSK_Text();
  1301.             }
  1302.             mmi_pen_editor_set_left_soft_key_select();
  1303.             set_left_softkey_function(mmi_pen_editor_left_soft_key_handler, KEY_EVENT_UP);
  1304.             set_left_softkey_function(mmi_pen_editor_hold_confirm, KEY_EVENT_DOWN);
  1305.             gPenEditorSelectCandidate = MMI_TRUE;
  1306.             switch (gPenEditorInputBoxType)
  1307.             {
  1308.                 case PEN_EDITOR_EMS_INPUT_BOX:
  1309.                 case PEN_EDITOR_MULTILINE_INPUT_BOX:
  1310.                 case PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX:
  1311.                 case PEN_EDITOR_DICT_MULTILINE_INPUT_BOX:
  1312.                     mmi_pen_editor_smart_bpmf_pinyin_register_arrow_keys();
  1313.                     break;
  1315.                 default:
  1316.                     break;
  1317.             }
  1318.             mmi_pen_editor_set_right_softkey(PEN_EDITOR_RSK_CLEAR);
  1319.         }
  1320.         else
  1321.         {
  1322.             mmi_pen_editor_del_key_sequence(&g_pen_editor_key_sequence);
  1323.         }
  1324.         mmi_pen_editor_show_composition_area(MMI_TRUE, PEN_EDITOR_CANDIDATE_ON_AND_FOCUS);
  1325.     }
  1326.     gdi_layer_unlock_frame_buffer();
  1327.     gdi_lcd_repaint_all();
  1328.     mmi_pen_editor_change_handwriting_area();
  1329. }
  1332. /*****************************************************************************
  1333.  * FUNCTION
  1334.  *  mmi_pen_editor_smart_bpmf_pinyin_key_up_handler
  1335.  * DESCRIPTION
  1336.  *  The handler of key up(number keys) in Smart BPMF/PinYin
  1337.  * PARAMETERS
  1338.  *  key     [IN]        The key index
  1339.  * RETURNS
  1340.  *  void
  1341.  *****************************************************************************/
  1342. void mmi_pen_editor_smart_bpmf_pinyin_key_up_handler(S32 key)
  1343. {
  1344.     /*----------------------------------------------------------------*/
  1345.     /* Local Variables                                                */
  1346.     /*----------------------------------------------------------------*/
  1348.     /*----------------------------------------------------------------*/
  1349.     /* Code Body                                                      */
  1350.     /*----------------------------------------------------------------*/
  1351.     UI_UNUSED_PARAMETER(key);
  1352. }
  1355. /*****************************************************************************
  1356.  * FUNCTION
  1357.  *  mmi_pen_editor_chinese_stroke_get_candidates_by_key_sequence
  1358.  * DESCRIPTION
  1359.  *  Get the candidates from the key sequence for Chinese Stroke
  1360.  * PARAMETERS
  1361.  *  key_sequence        [IN]     The key sequence of Chinese Stroke
  1362.  * RETURNS
  1363.  *  The number of the candidates
  1364.  *****************************************************************************/
  1365. S32 mmi_pen_editor_chinese_stroke_get_candidates_by_key_sequence(mmi_pen_editor_key_sequence_struct *key_sequence)
  1366. {
  1367.     /*----------------------------------------------------------------*/
  1368.     /* Local Variables                                                */
  1369.     /*----------------------------------------------------------------*/
  1370.     UI_character_type candidate_buffer[PEN_EDITOR_MAX_CANDIDATE_SIZE];
  1371.     UI_character_type stroke_buffer[PEN_EDITOR_MAX_KEY_BUFFER_SIZE];
  1372.     U32 num = 0, i = 0;
  1374.     /*----------------------------------------------------------------*/
  1375.     /* Code Body                                                      */
  1376.     /*----------------------------------------------------------------*/
  1377.     num = mmi_ime_chinese_stroke_get_candidates_by_key_sequence(
  1378.             key_sequence->KeySequence,
  1379.             key_sequence->KeyLength,
  1380.             candidate_buffer,
  1381.             stroke_buffer);
  1382.     if (num)
  1383.     {
  1384.         mmi_pen_editor_reset_candidate_index();
  1385.         if ((g_pen_editor_composition_state.candidate_state == PEN_EDITOR_CANDIDATE_OFF))
  1386.         {
  1387.             int change_height = 0;
  1389.             if (PEN_EDITOR_VK_ON == gPenEditorVKState && (GUI_VIRTUAL_KEYBOARD_TRAY != MMI_virtual_keyboard.lang_type))
  1390.             {
  1391.                 mmi_pen_editor_vk_hide();
  1392.             }
  1393.             gPenEditorVKState = PEN_EDITOR_VK_OFF;
  1394.             change_height -= g_pen_editor_composition_input_box.height;
  1395.             mmi_pen_editor_resize_content_area(change_height);
  1396.             g_pen_editor_composition_state.candidate_state = PEN_EDITOR_CANDIDATE_ON_NOT_FOCUS;
  1397.         }
  1398.         gui_single_line_input_box_delete_all(&g_pen_editor_composition_input_box);
  1399.         for (i = 0; i < g_pen_editor_key_sequence.KeyLength; i++)
  1400.         {
  1401.             gui_single_line_input_box_insert_character(&g_pen_editor_composition_input_box, stroke_buffer[i]);
  1402.         }
  1403.         mmi_pen_editor_show_composition_area(MMI_FALSE, PEN_EDITOR_CANDIDATE_ON_NOT_FOCUS);
  1404.         gui_single_line_input_box_delete_all(&gPenEditorCandidateInputBox);
  1405.         for (i = 0; i < num; i++)
  1406.         {
  1407.             gui_single_line_input_box_insert_character(&gPenEditorCandidateInputBox, candidate_buffer[i]);
  1408.         }
  1409.         gui_single_line_input_box_goto_first_character(&gPenEditorCandidateInputBox);
  1410.         gui_single_line_input_box_next(&gPenEditorCandidateInputBox);
  1411.         mmi_pen_editor_show_candidate_area(MMI_TRUE, PEN_EDITOR_CANDIDATE_ON_AND_FOCUS);
  1412.     }
  1413.     return num;
  1414. }
  1417. /*****************************************************************************
  1418.  * FUNCTION
  1419.  *  mmi_pen_editor_smart_bpmf_pinyin_get_candidates_by_key_sequence
  1420.  * DESCRIPTION
  1421.  *  Get the candidates from the key sequence for Smart BPMF/PinYin
  1422.  * PARAMETERS
  1423.  *  key_sequence        [IN]         The key sequence of Smart BPMF/PinYin
  1424.  *  is_reset            [IN]         MMI_TRUE : Resest the index for the composition box
  1425.  *                                   MMI_FALSE : Do not resest the index for the composition box
  1426.  * RETURNS
  1427.  *  The number of the candidates
  1428.  *****************************************************************************/
  1429. S32 mmi_pen_editor_smart_bpmf_pinyin_get_candidates_by_key_sequence(
  1430.         mmi_pen_editor_key_sequence_struct *key_sequence,
  1431.         BOOL is_reset)
  1432. {
  1433.     /*----------------------------------------------------------------*/
  1434.     /* Local Variables                                                */
  1435.     /*----------------------------------------------------------------*/
  1436.     UI_character_type syllable_buffer[PEN_EDITOR_MAX_SYLLABLE_BUFFER_SIZE];
  1437.     UI_character_type candidate_buffer[PEN_EDITOR_MAX_CANDIDATE_SIZE];
  1438.     U32 num = 0, i = 0, j = 0, k = 0;
  1439.     S32 start_index,end_index;
  1441.     /*----------------------------------------------------------------*/
  1442.     /* Code Body                                                      */
  1443.     /*----------------------------------------------------------------*/
  1444.     if (is_reset)
  1445.     {
  1446.         start_index = 0;
  1447.         end_index = PEN_EDITOR_MAX_SYLLABLE_CANDIDATE_SIZE - 1;
  1448.     }
  1449.     else
  1450.     {
  1451.         start_index = g_pen_editor_composition_page * PEN_EDITOR_MAX_SYLLABLE_CANDIDATE_SIZE;
  1452.         end_index = (g_pen_editor_composition_page + 1) * PEN_EDITOR_MAX_SYLLABLE_CANDIDATE_SIZE - 1;
  1453.     }
  1454.     num = mmi_ime_smart_bpmf_pinyin_get_syllable_by_key_sequence(
  1455.             key_sequence->KeySequence,
  1456.             key_sequence->KeyLength,
  1457.             syllable_buffer,
  1458.             start_index,
  1459.             end_index);
  1460.     if (num)
  1461.     {
  1462.         mmi_pen_editor_reset_candidate_index();
  1463.         if (is_reset)
  1464.         {
  1465.             mmi_pen_editor_reset_composition_index();
  1466.         }
  1467.         if ((g_pen_editor_composition_state.candidate_state == PEN_EDITOR_CANDIDATE_OFF))
  1468.         {
  1469.             int change_height = 0;
  1471.             if (PEN_EDITOR_VK_ON == gPenEditorVKState && (GUI_VIRTUAL_KEYBOARD_TRAY != MMI_virtual_keyboard.lang_type))
  1472.             {
  1473.                 mmi_pen_editor_vk_hide();
  1474.             }
  1475.             gPenEditorVKState = PEN_EDITOR_VK_OFF;
  1476.             change_height -= g_pen_editor_composition_input_box.height;
  1477.             mmi_pen_editor_resize_content_area(change_height);
  1478.             g_pen_editor_composition_state.candidate_state = PEN_EDITOR_CANDIDATE_ON_AND_FOCUS;
  1479.         }
  1480.         memset(g_pen_editor_syllable_table, 0, sizeof(g_pen_editor_syllable_table));
  1481.         gui_single_line_input_box_delete_all(&g_pen_editor_composition_input_box);
  1482.         for (i = 0;; i++)
  1483.         {
  1484.             if (syllable_buffer[i])
  1485.             {
  1486.                 gui_single_line_input_box_insert_character(&g_pen_editor_composition_input_box, syllable_buffer[i]);
  1487.                 if (syllable_buffer[i] == 0x20)
  1488.                 {
  1489.                     g_pen_editor_syllable_table[j][k] = '';
  1490.                     j++;
  1491.                     k = 0;
  1492.                 }
  1493.                 else
  1494.                 {
  1495.                     g_pen_editor_syllable_table[j][k++] = syllable_buffer[i];
  1496.                 }
  1497.             }
  1498.             else
  1499.             {
  1500.                 gui_single_line_input_box_insert_character(&g_pen_editor_composition_input_box, 0x20);
  1501.                 g_pen_editor_syllable_table[j+1][0] = syllable_buffer[i];
  1502.                 break;
  1503.             }
  1504.         }
  1505.         gui_single_line_input_box_goto_first_character(&g_pen_editor_composition_input_box);
  1506.         for (i = 0;;)
  1507.         {
  1508.             UI_character_type ch, ch1, ch2;
  1510.             ch1 = *(g_pen_editor_composition_input_box.current_text_p - 2);
  1511.             ch2 = *(g_pen_editor_composition_input_box.current_text_p - 1);
  1512.             ch = ch1 | (ch2 << 8);
  1513.             if (ch == 0x20)
  1514.             {
  1515.                 i++;
  1516.             }
  1517.             if (i == g_pen_editor_composition_index)
  1518.             {
  1519.                 for (i = 0; i < g_pen_editor_key_sequence.KeyLength + 1; i++)
  1520.                 {
  1521.                     gui_single_line_input_box_next(&g_pen_editor_composition_input_box);
  1522.                 }
  1523.                 break;
  1524.             }
  1525.             gui_single_line_input_box_next(&g_pen_editor_composition_input_box);
  1526.         }
  1527.         gui_single_line_input_box_previous(&g_pen_editor_composition_input_box);
  1528.         gui_single_line_input_box_highlight_cursor_number(
  1529.             &g_pen_editor_composition_input_box,
  1530.             g_pen_editor_key_sequence.KeyLength);
  1531.         //mmi_pen_editor_show_composition_area(MMI_TRUE, PEN_EDITOR_CANDIDATE_ON_AND_FOCUS);
  1532.         num = mmi_ime_get_candidates_by_composition(
  1533.                 g_pen_editor_syllable_table[g_pen_editor_composition_index],
  1534.                 candidate_buffer);
  1535.         gui_single_line_input_box_delete_all(&gPenEditorCandidateInputBox);
  1536.         for (i = 0; i < num; i++)
  1537.         {
  1538.             gui_single_line_input_box_insert_character(&gPenEditorCandidateInputBox, candidate_buffer[i]);
  1539.         }
  1540.         gui_single_line_input_box_goto_first_character(&gPenEditorCandidateInputBox);
  1541.         gui_single_line_input_box_next(&gPenEditorCandidateInputBox);
  1542.         mmi_pen_editor_show_candidate_area(MMI_TRUE, PEN_EDITOR_CANDIDATE_ON_NOT_FOCUS);
  1543.     }
  1544.     return num;
  1545. }
  1548. /*****************************************************************************
  1549.  * FUNCTION
  1550.  *  mmi_pen_editor_cancel_handwriting
  1551.  * DESCRIPTION
  1552.  *  Cancel the handwriting. This function is usually used when key down
  1553.  * PARAMETERS
  1554.  *  void
  1555.  * RETURNS
  1556.  *  void
  1557.  *****************************************************************************/
  1558. void mmi_pen_editor_cancel_handwriting(void)
  1559. {
  1560.     /*----------------------------------------------------------------*/
  1561.     /* Local Variables                                                */
  1562.     /*----------------------------------------------------------------*/
  1564.     /*----------------------------------------------------------------*/
  1565.     /* Code Body                                                      */
  1566.     /*----------------------------------------------------------------*/
  1567.     if (!gPenEditorFirstStroke)
  1568.     {
  1569.         int changed_height = 0;
  1570.         if (gPenEditorGDIHandler != NULL && *gPenEditorGDIHandler != GDI_ERROR_HANDLE)
  1571.         {
  1572.             gdi_layer_push_and_set_active(*gPenEditorGDIHandler);
  1573.             gdi_layer_set_source_key(TRUE, GDI_COLOR_TRANSPARENT);
  1574.             gdi_layer_clear(GDI_COLOR_TRANSPARENT);
  1575.             gdi_layer_pop_and_restore_active();
  1576.         }
  1577.         gui_cancel_timer(mmi_pen_editor_stroke_up_timer_handler);
  1578.         mmi_pen_begin_strokes_of_character();
  1579.         gdi_layer_lock_frame_buffer();
  1580.         gPenEditorVKState = PEN_EDITOR_VK_ON;
  1581.         if (gPenEditorShowVK && (gPenEditorCandidateInputBox.y >= (PEN_EDITOR_Y_OF_CANDIDATE_INPUT_BOX_IN_BOTTOM)))
  1582.         {
  1583.             /* W05.47 Change the Input Control Height when the VK is not Tray Type */
  1584.             if (!(GUI_VIRTUAL_KEYBOARD_TRAY == MMI_virtual_keyboard.lang_type
  1585.                   || GUI_VIRTUAL_KEYBOARD_EMPTY_TRAY == MMI_virtual_keyboard.lang_type
  1586.                   || GUI_VIRTUAL_KEYBOARD_NUMBER_TRAY == MMI_virtual_keyboard.lang_type
  1587.                   || GUI_VIRTUAL_KEYBOARD_NUMBER_DOT_TRAY == MMI_virtual_keyboard.lang_type))
  1588.             {
  1589.                 changed_height = gPenEditorCandidateInputBox.height;
  1590.                 if (gPenEditorVKCandidate)
  1591.                 {
  1592.                     changed_height -= gPenEditorCandidateInputBox.height;
  1593.                 }
  1594.                 changed_height -= MMI_virtual_keyboard.height;
  1595.                 if (PEN_EDITOR_DICT_MULTILINE_INPUT_BOX != gPenEditorInputBoxType)
  1596.                 {
  1597.                     mmi_pen_editor_resize_content_area(changed_height);
  1598.                 }
  1599.             }
  1600.         }
  1602.         if (gPenEditorShowVK)
  1603.         {
  1604.             mmi_pen_editor_clear_and_show_virtual_keyboard_area();
  1605.         }
  1607.         if (gPenEditorVKCandidate)
  1608.         {
  1609.             if (gPenEditorShowVK)
  1610.             {
  1611.                 gui_move_single_line_input_box(
  1612.                     &gPenEditorCandidateInputBox,
  1613.                     gPenEditorCandidateInputBox.x,
  1614.                     MMI_virtual_keyboard.y - gPenEditorCandidateInputBox.height - 2);
  1615.             }
  1616.             mmi_pen_editor_hide_candidate_area();
  1617.         }
  1618.         gdi_layer_unlock_frame_buffer();
  1619.         gdi_lcd_repaint_all();
  1620.         return;
  1621.     }
  1622. }
  1625. /*****************************************************************************
  1626.  * FUNCTION
  1627.  *  mmi_pen_editor_set_handwriting_style
  1628.  * DESCRIPTION
  1629.  *  Set the current handwriting Style
  1630.  * PARAMETERS
  1631.  *  style       [IN]        PEN_EDITOR_HANDWRITING_STYLE_FULL_SCREEN : Handwriting on the full screen
  1632.  *                          PEN_EDITOR_HANDWRITING_STYLE_MULTI_BLOCK : Handwriting with Handwriting blocks
  1633.  * RETURNS
  1634.  *  void
  1635.  *****************************************************************************/
  1636. void mmi_pen_editor_set_handwriting_style(mmi_pen_editor_handwriting_style_enum style)
  1637. {
  1638.     /*----------------------------------------------------------------*/
  1639.     /* Local Variables                                                */
  1640.     /*----------------------------------------------------------------*/
  1642.     /*----------------------------------------------------------------*/
  1643.     /* Code Body                                                      */
  1644.     /*----------------------------------------------------------------*/
  1645.     g_pen_editor_handwriting_style = style;
  1646. }
  1649. /*****************************************************************************
  1650.  * FUNCTION
  1651.  *  mmi_pen_editor_get_handwriting_style
  1652.  * DESCRIPTION
  1653.  *  To get the current handwriting style
  1654.  * PARAMETERS
  1655.  *  void
  1656.  * RETURNS
  1657.  *  PEN_EDITOR_HANDWRITING_STYLE_FULL_SCREEN : Handwriting on the full screen
  1658.  *  PEN_EDITOR_HANDWRITING_STYLE_MULTI_BLOCK : Handwriting with Handwriting blocks
  1659.  *****************************************************************************/
  1660. mmi_pen_editor_handwriting_style_enum mmi_pen_editor_get_handwriting_style(void)
  1661. {
  1662.     /*----------------------------------------------------------------*/
  1663.     /* Local Variables                                                */
  1664.     /*----------------------------------------------------------------*/
  1666.     /*----------------------------------------------------------------*/
  1667.     /* Code Body                                                      */
  1668.     /*----------------------------------------------------------------*/
  1669.     return g_pen_editor_handwriting_style;
  1670. }
  1673. /*****************************************************************************
  1674.  * FUNCTION
  1675.  *  mmi_pen_editor_multi_block_stroke_up_handler
  1676.  * DESCRIPTION
  1677.  *  Draw the last point of the stroke and start the timer to check this is the last stroke or not if pos in the handwriting block
  1678.  * PARAMETERS
  1679.  *  pos     [IN]        The position of the stroke up event
  1680.  * RETURNS
  1681.  *  void
  1682.  *****************************************************************************/
  1683. void mmi_pen_editor_multi_block_stroke_up_handler(mmi_pen_point_struct pos)
  1684. {
  1685.     /*----------------------------------------------------------------*/
  1686.     /* Local Variables                                                */
  1687.     /*----------------------------------------------------------------*/
  1688.     int active_block;
  1690.     /*----------------------------------------------------------------*/
  1691.     /* Code Body                                                      */
  1692.     /*----------------------------------------------------------------*/
  1693.     /* if hand writing is not enabled, it should not go here */
  1694.     if (!gPenEditorEnableHandWriting)
  1695.     {
  1696.         MMI_DBG_ASSERT(0);
  1697.         return;
  1698.     }
  1699.     active_block = mmi_pen_editor_handwriting_check_block(pos);
  1700.     if (active_block)
  1701.     {
  1702.         mmi_pen_editor_stroke_move_handler(pos);
  1703.         gui_cancel_timer(mmi_pen_editor_stroke_up_timer_handler);
  1704.         /* The end of the stroke, if no more stroke in the period, the end of the character */
  1705.         gui_start_timer(PEN_EDITOR_CHARACTER_END_PERIOD, mmi_pen_editor_stroke_up_timer_handler);
  1706.     }
  1707.     gPenEditorPreviousPoint.x = -1;
  1708.     gPenEditorPreviousPoint.y = -1;
  1709. }
  1712. /*****************************************************************************
  1713.  * FUNCTION
  1714.  *  mmi_pen_editor_handwriting_check_block
  1715.  * DESCRIPTION
  1716.  *  To check the position is on which block (0 : out of handwriting area)
  1717.  * PARAMETERS
  1718.  *  pos     [IN]        The position of the point to check
  1719.  * RETURNS
  1720.  *  Which block the position is on
  1721.  *****************************************************************************/
  1722. S32 mmi_pen_editor_handwriting_check_block(mmi_pen_point_struct pos)
  1723. {
  1724.     /*----------------------------------------------------------------*/
  1725.     /* Local Variables                                                */
  1726.     /*----------------------------------------------------------------*/
  1727.     MMI_BOOL ret = MMI_FALSE;
  1728.     S32 active_block = 0;
  1730.     /*----------------------------------------------------------------*/
  1731.     /* Code Body                                                      */
  1732.     /*----------------------------------------------------------------*/
  1733.     ret = PEN_CHECK_BOUND(
  1734.             pos.x,
  1735.             pos.y,
  1736.             1,
  1737.             MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT + gPenEditorCandidateInputBox.height + 3,
  1738.             ((UI_device_width - 2) >> 1),
  1739.             PEN_EDITOR_BLOCK_HEIGHT - gPenEditorCandidateInputBox.height + 3);
  1740.     if (ret)
  1741.     {
  1742.         active_block = 1;
  1743.     }
  1745.     ret = PEN_CHECK_BOUND(
  1746.             pos.x,
  1747.             pos.y,
  1748.             1 + ((UI_device_width - 2) >> 1),
  1749.             MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT + gPenEditorCandidateInputBox.height + 3,
  1750.             ((UI_device_width - 2) >> 1),
  1751.             PEN_EDITOR_BLOCK_HEIGHT - gPenEditorCandidateInputBox.height + 3);
  1752.     if (ret)
  1753.     {
  1754.         active_block = 2;
  1755.     }
  1756.     return active_block;
  1757. }
  1760. /*****************************************************************************
  1761.  * FUNCTION
  1762.  *  mmi_pen_editor_handwriting_direct_input
  1763.  * DESCRIPTION
  1764.  *  Insert the recognizing result from handwriting to the input box directly
  1765.  * PARAMETERS
  1766.  *  void
  1767.  * RETURNS
  1768.  *  void
  1769.  *****************************************************************************/
  1770. void mmi_pen_editor_handwriting_direct_input(void)
  1771. {
  1772.     /*----------------------------------------------------------------*/
  1773.     /* Local Variables                                                */
  1774.     /*----------------------------------------------------------------*/
  1775.     UI_character_type candidate_buffer[10];
  1776.     int num = 0;
  1778.     /*----------------------------------------------------------------*/
  1779.     /* Code Body                                                      */
  1780.     /*----------------------------------------------------------------*/
  1781.     /* The end of the character, pass the stroke data for hand writing recognization */
  1782.     gui_cancel_timer(mmi_pen_editor_stroke_up_timer_handler);
  1783.     mmi_pen_end_strokes_of_character();
  1784.     /* mmi_pen_end_strokes_of_character_with_dropping_last_point(); */
  1785. #if defined(__MMI_HAND_WRITING_GET_STROKES__)
  1786.     mmi_pen_editor_save_stroke_to_file();
  1787. #endif 
  1788.     gdi_layer_push_and_set_active(*gPenEditorGDIHandler);
  1789.     gdi_layer_clear(GDI_COLOR_TRANSPARENT);
  1790.     gdi_layer_pop_and_restore_active();
  1791.     gPenEditorFirstStroke = MMI_TRUE;
  1793.     switch (MMI_current_input_mode)
  1794.     {
  1795. #ifdef __MMI_LANG_TR_CHINESE__      //KP Jerry add on 2007-4-17
  1796.         case INPUT_MODE_TR_MULTITAP_BOPOMO:
  1797.         case INPUT_MODE_TR_BOPOMO:
  1798.         case INPUT_MODE_TR_STROKE:
  1799.             num = mmi_pen_editor_hand_writing_get_candidates(
  1800.                     (U16*) gPenEditorStrokeBuffer,
  1801.                     candidate_buffer,
  1802.                     PEN_EDITOR_TRADITIONAL_CHINESE,
  1803.                     1);
  1804.             break;
  1805. #endif/*__MMI_LANG_TR_CHINESE__*/      //KP Jerry add on 2007-4-17
  1807. #ifdef __MMI_LANG_SM_CHINESE__      //KP Jerry add on 2007-4-17
  1808.         case INPUT_MODE_SM_MULTITAP_PINYIN:
  1809.         case INPUT_MODE_SM_PINYIN:
  1810.         case INPUT_MODE_SM_STROKE:
  1811.             num = mmi_pen_editor_hand_writing_get_candidates(
  1812.                     (U16*) gPenEditorStrokeBuffer,
  1813.                     candidate_buffer,
  1814.                     PEN_EDITOR_SIMPLIFIED_CHINESE,
  1815.                     1);
  1816.             break;
  1817. #endif/*__MMI_LANG_SM_CHINESE__*/      //KP Jerry add on 2007-4-17
  1819. //KP Jerry add on 2007-4-17 start
  1820. #ifdef __MMI_LANG_VIETNAMESE__
  1821.         case INPUT_MODE_MULTITAP_UPPERCASE_VIETNAMESE:
  1822.         case INPUT_MODE_SMART_UPPERCASE_VIETNAMESE:
  1823.             num = mmi_pen_editor_hand_writing_get_candidates(
  1824.                     (U16*) gPenEditorStrokeBuffer,
  1825.                     candidate_buffer,
  1826.                     PEN_EDITOR_UPPER_CASE_ENGLISH,
  1827.                     1);
  1828.             break;
  1830.         case INPUT_MODE_MULTITAP_LOWERCASE_VIETNAMESE:
  1831.         case INPUT_MODE_SMART_LOWERCASE_VIETNAMESE:
  1832.             num = mmi_pen_editor_hand_writing_get_candidates(
  1833.                     (U16*) gPenEditorStrokeBuffer,
  1834.                     candidate_buffer,
  1835.                     PEN_EDITOR_LOWER_CASE_ENGLISH,
  1836.                     1);
  1837.             break;
  1838. #endif /* __MMI_LANG_VIETNAMESE__ */ 
  1840. #ifdef __MMI_LANG_RUSSIAN__
  1841.         case INPUT_MODE_MULTITAP_UPPERCASE_RUSSIAN:
  1842.         case INPUT_MODE_SMART_UPPERCASE_RUSSIAN:
  1843.             num = mmi_pen_editor_hand_writing_get_candidates(
  1844.                     (U16*) gPenEditorStrokeBuffer,
  1845.                     candidate_buffer,
  1846.                     PEN_EDITOR_UPPER_CASE_ENGLISH,
  1847.                     1);
  1848.             break;
  1850.         case INPUT_MODE_MULTITAP_LOWERCASE_RUSSIAN:
  1851.         case INPUT_MODE_SMART_LOWERCASE_RUSSIAN:
  1852.             num = mmi_pen_editor_hand_writing_get_candidates(
  1853.                     (U16*) gPenEditorStrokeBuffer,
  1854.                     candidate_buffer,
  1855.                     PEN_EDITOR_LOWER_CASE_ENGLISH,
  1856.                     1);
  1857.             break;
  1858. #endif /* __MMI_LANG_RUSSIAN__ */ 
  1860. #ifdef __MMI_LANG_THAI__
  1861.         case INPUT_MODE_MULTITAP_THAI:
  1862.         case INPUT_MODE_SMART_THAI:
  1863.             num = mmi_pen_editor_hand_writing_get_candidates(
  1864.                     (U16*) gPenEditorStrokeBuffer,
  1865.                     candidate_buffer,
  1866.                     PEN_EDITOR_UPPER_CASE_ENGLISH,
  1867.                     1);
  1868.             break;
  1869. #endif /* __MMI_LANG_THAI__ */ 
  1870. //KP Jerry add on 2007-4-17 end
  1872.         case INPUT_MODE_MULTITAP_UPPERCASE_ABC:
  1873.         case INPUT_MODE_SMART_UPPERCASE_ABC:
  1874.         case INPUT_MODE_MULTITAP_UPPERCASE_ABC_NO_NUMERIC:
  1875.             num = mmi_pen_editor_hand_writing_get_candidates(
  1876.                     (U16*) gPenEditorStrokeBuffer,
  1877.                     candidate_buffer,
  1878.                     PEN_EDITOR_UPPER_CASE_ENGLISH,
  1879.                     1);
  1880.             break;
  1882.         case INPUT_MODE_MULTITAP_LOWERCASE_ABC:
  1883.         case INPUT_MODE_SMART_LOWERCASE_ABC:
  1884.         case INPUT_MODE_MULTITAP_LOWERCASE_ABC_NO_NUMERIC:
  1885.             num = mmi_pen_editor_hand_writing_get_candidates(
  1886.                     (U16*) gPenEditorStrokeBuffer,
  1887.                     candidate_buffer,
  1888.                     PEN_EDITOR_LOWER_CASE_ENGLISH,
  1889.                     1);
  1890.             break;
  1892.         case INPUT_MODE_123:
  1893.         case INPUT_MODE_123_SYMBOLS:
  1894.             num = mmi_pen_editor_hand_writing_get_candidates(
  1895.                     (U16*) gPenEditorStrokeBuffer,
  1896.                     candidate_buffer,
  1897.                     PEN_EDITOR_NUMBER,
  1898.                     1);
  1899.             break;
  1901.         default:
  1902.             break;
  1903.     }
  1904.     if (num)
  1905.     {
  1906.         mmi_pen_editor_input_character(candidate_buffer[0], MMI_FALSE);
  1907.     }
  1908.     g_pen_editor_active_block = 0;
  1909.     gPenEditorVKState = PEN_EDITOR_VK_ON;
  1910.     mmi_pen_begin_strokes_of_character();
  1911. }
  1914. /*****************************************************************************
  1915.  * FUNCTION
  1916.  *  mmi_pen_editor_draw_handwriting_block
  1917.  * DESCRIPTION
  1918.  *  To draw the handwriting block area
  1919.  * PARAMETERS
  1920.  *  void
  1921.  * RETURNS
  1922.  *  void
  1923.  *****************************************************************************/
  1924. void mmi_pen_editor_draw_handwriting_block(void)
  1925. {
  1926.     /*----------------------------------------------------------------*/
  1927.     /* Local Variables                                                */
  1928.     /*----------------------------------------------------------------*/
  1929.     color c;
  1931.     /*----------------------------------------------------------------*/
  1932.     /* Code Body                                                      */
  1933.     /*----------------------------------------------------------------*/
  1934.     c.r = 255;
  1935.     c.g = 255;
  1936.     c.b = 255;
  1937.     c.alpha = 100;
  1938.     if (wgui_is_wallpaper_on_bottom() == MMI_TRUE)
  1939.     {
  1940.         gdi_draw_solid_rect(
  1941.             0,
  1942.             MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT - 2,
  1943.             UI_device_width - 1,
  1944.             MMI_content_y + MMI_content_height - 1,
  1945.             GDI_COLOR_TRANSPARENT);
  1946.     }
  1947.     else
  1948.     {
  1949.         gui_fill_rectangle(
  1950.             0,
  1951.             MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT - 2,
  1952.             UI_device_width - 1,
  1953.             MMI_content_y + MMI_content_height - 1,
  1954.             c);
  1955.     }
  1956. gdi_draw_rect(
  1957. 1,
  1958.     MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT + gPenEditorCandidateInputBox.height + 3, 
  1959. UI_device_width - 2,
  1960. MMI_content_y + MMI_content_height - 1,
  1961. GDI_COLOR_BLACK);
  1962. gdi_draw_line(
  1963. 1 + ((UI_device_width - 2) >> 1),
  1964.     MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT + gPenEditorCandidateInputBox.height + 3, 
  1965. 1 + ((UI_device_width - 2) >> 1),
  1966. MMI_content_y + MMI_content_height - 1,
  1967. GDI_COLOR_BLACK);
  1968. gui_move_single_line_input_box(
  1969. &gPenEditorCandidateInputBox, 
  1970. gPenEditorCandidateInputBox.x, 
  1971. MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT + 1);
  1972. }
  1975. /*****************************************************************************
  1976.  * FUNCTION
  1977.  *  mmi_pen_editor_reset_LSK_and_RSK_state
  1978.  * DESCRIPTION
  1979.  *  Reset LSK and RSK label and function to un-selected state
  1980.  * PARAMETERS
  1981.  *  void
  1982.  * RETURNS
  1983.  *  void
  1984.  *****************************************************************************/
  1985. void mmi_pen_editor_reset_LSK_and_RSK_state(void)
  1986. {
  1987.     /*----------------------------------------------------------------*/
  1988.     /* Local Variables                                                */
  1989.     /*----------------------------------------------------------------*/
  1992.     /*----------------------------------------------------------------*/
  1993.     /* Code Body                                                      */
  1994.     /*----------------------------------------------------------------*/
  1995.     if (gPenEditorSelectCandidate)
  1996.     {
  1997.         gPenEditorSelectCandidate = MMI_FALSE;
  1998.         mmi_pen_editor_set_left_soft_key();
  1999.         switch (gPenEditorInputBoxType)
  2000.         {
  2001.             case PEN_EDITOR_EMS_INPUT_BOX:
  2002.                 /* LSK */
  2003.                 register_EMS_inputbox_keys();
  2004.                 /* RSK */
  2005.                 handle_category28_input();
  2006.                 wgui_set_EMS_inputbox_RSK();
  2007.                 break;
  2009.             case PEN_EDITOR_MULTILINE_INPUT_BOX:
  2010.             case PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX:
  2011.             case PEN_EDITOR_DICT_MULTILINE_INPUT_BOX:
  2012.                 /* LSK */
  2013.                 register_multiline_inputbox_keys();
  2014.                 /* RSK */
  2015.                 wgui_handle_inputbox_input();
  2016.                 wgui_set_RSK();
  2017.                 
  2018.                 if (PEN_EDITOR_DICT_MULTILINE_INPUT_BOX == gPenEditorInputBoxType)
  2019.                 {
  2020.                     cat201_register_key_func();
  2021.                 }
  2022.                 break;
  2024.             default:
  2025.                 break;
  2026.         }
  2027.         mmi_pen_editor_reset_vk_text(&gPenEditorVKText);
  2028.         wgui_set_virtual_keyboard_display_area((U8*) gPenEditorVKText.VKText, MMI_FALSE);
  2029.     }     
  2030. }
  2033. /*****************************************************************************
  2034.  * FUNCTION
  2035.  *  mmi_pen_editor_enable_multi_block_handwriting
  2036.  * DESCRIPTION
  2037.  *  Change from the main virtual keybaord mode to the multi-block handwriting mode. Enable the stroke mode.
  2038.  * PARAMETERS
  2039.  *  void
  2040.  * RETURNS
  2041.  *  void
  2042.  *****************************************************************************/
  2043. void mmi_pen_editor_enable_multi_block_handwriting(void)
  2044. {
  2045.     /*----------------------------------------------------------------*/
  2046.     /* Local Variables                                                */
  2047.     /*----------------------------------------------------------------*/
  2048.     int changed_height = 0;
  2049.     U16 input_type_only = MMI_current_input_type & INPUT_TYPE_MASK;
  2051.     /*----------------------------------------------------------------*/
  2052.     /* Code Body                                                      */
  2053.     /*----------------------------------------------------------------*/
  2054.     mmi_pen_editor_hide_virtual_keyboard_area();
  2055. changed_height = gPenEditorCandidateInputBox.height;
  2056.     if (changed_height < MMI_virtual_keyboard.height)
  2057.     {
  2058.         changed_height = MMI_virtual_keyboard.height;
  2059.         if (gPenEditorVKCandidate)
  2060.         {
  2061.             changed_height += (gPenEditorCandidateInputBox.height + 1);
  2062.         }
  2063.         gPenEditorVKCandidate = MMI_FALSE;
  2064.     }
  2065.     changed_height -= PEN_EDITOR_BLOCK_HEIGHT;
  2066. gui_reset_clip();
  2067. mmi_pen_editor_resize_content_area(changed_height);
  2068.     mmi_pen_editor_draw_handwriting_block();
  2069.     wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_TRAY);
  2070.     if (PEN_EDITOR_INLINE_TEXT == gPenEditorInputBoxType
  2071.         || PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX == gPenEditorInputBoxType)
  2072.     {
  2073.         s32 temp_multiline_height = MMI_multiline_inputbox.height;
  2074.         MMI_BOOL temp_VKCandidate = gPenEditorVKCandidate;
  2075.         gui_virtual_keyboard_language_enum keyboard_type = MMI_virtual_keyboard.lang_type;
  2077.         mmi_pen_editor_vk_list_menu_resize();
  2078.         if (PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX == gPenEditorInputBoxType)
  2079.         {
  2080.             gui_resize_multi_line_input_box(
  2081.                 &MMI_multiline_inputbox,
  2082.                 MMI_multiline_inputbox.width,
  2083.                 temp_multiline_height);
  2084.             redraw_fixed_list();
  2085.             redraw_current_inline_item();
  2086.             gPenEditorVKCandidate = temp_VKCandidate;
  2087.         }
  2088.         wgui_setup_virtual_keyboard(keyboard_type);
  2089.     }
  2090.     wgui_move_virtual_keyboard(
  2091.         MMI_virtual_keyboard.x,
  2092.         MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT + 3);
  2093.     mmi_pen_editor_clear_and_show_virtual_keyboard_area();
  2094.     if (!(INPUT_TYPE_NUMERIC_PASSWORD == input_type_only ||
  2095.           INPUT_TYPE_SAT_NUMERIC_PASSWORD == input_type_only) && (!g_pen_editor_disable_handwriting))
  2096.     {
  2097.     g_multi_block_stroke_area[0].x1 = 3;
  2098.             g_multi_block_stroke_area[0].y1 =
  2099.                 MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT +
  2100.                 mmi_pen_editor_compute_candidate_input_box_height() + 4;
  2101.             g_multi_block_stroke_area[0].x2 = (UI_device_width >> 1) - 2;
  2102.     g_multi_block_stroke_area[0].y2 = MMI_content_y + MMI_content_height - 3;
  2103.     g_multi_block_stroke_area[1].x1 = (UI_device_width >> 1) + 1;
  2104.             g_multi_block_stroke_area[1].y1 =
  2105.                 MMI_content_y + MMI_content_height - PEN_EDITOR_BLOCK_HEIGHT +
  2106.                 mmi_pen_editor_compute_candidate_input_box_height() + 4;
  2107.             g_multi_block_stroke_area[1].x2 = UI_device_width - 3;
  2108.     g_multi_block_stroke_area[1].y2 = MMI_content_y + MMI_content_height - 3;
  2110. gPenEditorEnableHandWriting = MMI_TRUE;
  2111.         mmi_pen_start_capture_strokes(
  2112.             PEN_EDITOR_STROKE_BUFFER_SIZE,
  2113.             gPenEditorStrokeBuffer,
  2114.             2,
  2115.             g_multi_block_stroke_area,
  2116.             NULL);
  2117.         memcpy(
  2118.             &g_pen_editor_original_handwriting_area,
  2119.             &g_multi_block_stroke_area,
  2120.             sizeof(mmi_pen_handwriting_area_struct));
  2121.         
  2122.         /*
  2123.          * 06.38 Fixing LSK/RSK didnt be properly set when changing state 
  2124.          * from Virtual Keyboard to Multi-Block HandWriting in the case of
  2125.          * Candidate Inputbox in selection state.
  2126.          */
  2127.         mmi_pen_editor_reset_LSK_and_RSK_state();
  2129.         mmi_pen_register_stroke_down_handler(mmi_pen_editor_multi_block_stroke_down_handler);
  2130.         mmi_pen_register_stroke_move_handler(NULL, NULL, mmi_pen_editor_multi_block_stroke_move_handler);
  2131.         mmi_pen_register_stroke_up_handler(mmi_pen_editor_multi_block_stroke_up_handler);
  2133.         mmi_pen_editor_hand_writing_initailize();
  2134.         mmi_pen_begin_strokes_of_character();
  2135.     }
  2136. }
  2139. /*****************************************************************************
  2140.  * FUNCTION
  2141.  *  mmi_pen_editor_disable_multi_block_handwriting
  2142.  * DESCRIPTION
  2143.  *  Change Multi-Block handwriting to the main virtual keyboard mode. Disable the stroke mode.
  2144.  * PARAMETERS
  2145.  *  void
  2146.  * RETURNS
  2147.  *  void
  2148.  *****************************************************************************/
  2149. void mmi_pen_editor_disable_multi_block_handwriting(void)
  2150. {
  2151.     /*----------------------------------------------------------------*/
  2152.     /* Local Variables                                                */
  2153.     /*----------------------------------------------------------------*/
  2154.     int changed_height = 0;
  2156.     /*----------------------------------------------------------------*/
  2157.     /* Code Body                                                      */
  2158.     /*----------------------------------------------------------------*/
  2159.     mmi_pen_stop_capture_strokes();
  2160.     if (PEN_EDITOR_QUICK_SEARCH_SINGLE_LINE_INPU_BOX == gPenEditorInputBoxType)
  2161.     {
  2162.         changed_height = MMI_virtual_keyboard.height;
  2163.         mmi_pen_editor_set_virtual_keyboard_by_input_mode(MMI_current_input_mode);
  2164.         changed_height -= MMI_virtual_keyboard.height;
  2165.         mmi_pen_editor_resize_content_area(changed_height);
  2166.         RedrawCategoryControlledArea200Screen(NULL);
  2167.         return;
  2168.     }
  2169.     if (GUI_VIRTUAL_KEYBOARD_TRAY == MMI_virtual_keyboard.lang_type)
  2170.     {
  2171. changed_height = PEN_EDITOR_BLOCK_HEIGHT;
  2172. //KP Jerry modify on 2007-4-17 start
  2173.         if (INPUT_MODE_MULTITAP_LOWERCASE_ABC == MMI_current_input_mode ||     //KP Jerry remove "else" for adjust them order on 2007-4-16
  2174.                  INPUT_MODE_SMART_LOWERCASE_ABC == MMI_current_input_mode ||
  2175.                  INPUT_MODE_MULTITAP_LOWERCASE_ABC_NO_NUMERIC == MMI_current_input_mode)
  2176.         {
  2177.             if (gPenEditorVKCandidate)
  2178.             {
  2179.                 changed_height += gPenEditorCandidateInputBox.height;
  2180.             }
  2181.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_ENGLISH);
  2182.         }
  2183.         else if (INPUT_MODE_MULTITAP_UPPERCASE_ABC == MMI_current_input_mode ||
  2184.                  INPUT_MODE_SMART_UPPERCASE_ABC == MMI_current_input_mode ||
  2185.                  INPUT_MODE_MULTITAP_UPPERCASE_ABC_NO_NUMERIC == MMI_current_input_mode)
  2186.         {
  2187.             if (gPenEditorVKCandidate)
  2188.             {
  2189.                 changed_height += gPenEditorCandidateInputBox.height;
  2190.             }
  2191.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_ENGLISH_UPPERCASE);
  2192.         }
  2193.         else if (INPUT_MODE_123 == MMI_current_input_mode ||
  2194.                  INPUT_MODE_123_SYMBOLS == MMI_current_input_mode)
  2195.         {
  2196.             if (gPenEditorVKCandidate)
  2197.             {
  2198.                 changed_height += gPenEditorCandidateInputBox.height;
  2199.             }
  2200.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_NUMBER);
  2201.         }
  2203. #ifdef __MMI_LANG_TR_CHINESE__      //KP Jerry add on 2007-4-16
  2204.         else if (INPUT_MODE_TR_MULTITAP_BOPOMO == MMI_current_input_mode || INPUT_MODE_TR_BOPOMO == MMI_current_input_mode)     //KP Jerry delete "INPUT_MODE_TR_STROKE == MMI_current_input_mode" on 2007-3-21
  2205.         {
  2206.             if (!gPenEditorVKCandidate)
  2207.             {
  2208.                 changed_height -= (gPenEditorCandidateInputBox.height + 1);
  2209.                 gPenEditorVKCandidate = MMI_TRUE;
  2210.             }
  2211.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_BOPOMO);
  2212.         }
  2213. //KP Jerry add on 2007-3-21 start
  2214.         else if(INPUT_MODE_TR_STROKE==MMI_current_input_mode)
  2215.         {
  2216.             if (!gPenEditorVKCandidate)
  2217.             {
  2218.                 changed_height -= (gPenEditorCandidateInputBox.height + 1);
  2219.                 gPenEditorVKCandidate = MMI_TRUE;
  2220.             }
  2221.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_SYMBOL);
  2222.         }
  2223. //KP Jerry add on 2007-3-21 end
  2224. #endif/*__MMI_LANG_TR_CHINESE__*/      //KP Jerry add on 2007-4-16
  2226. #ifdef __MMI_LANG_SM_CHINESE__      //KP Jerry add on 2007-4-16
  2227.         else if (INPUT_MODE_SM_MULTITAP_PINYIN == MMI_current_input_mode || INPUT_MODE_SM_PINYIN == MMI_current_input_mode)     //KP Jerry delete "INPUT_MODE_SM_STROKE == MMI_current_input_mode" on 2007-3-21
  2228.         {
  2229.             if (!gPenEditorVKCandidate)
  2230.             {
  2231.                 changed_height -= (gPenEditorCandidateInputBox.height + 1);
  2232.                 gPenEditorVKCandidate = MMI_TRUE;
  2233.             }
  2234.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_PINYIN);
  2235.         }
  2236. //KP Jerry add on 2007-3-21 start
  2237.         else if(INPUT_MODE_SM_STROKE==MMI_current_input_mode)
  2238.         {
  2239.             if (!gPenEditorVKCandidate)
  2240.             {
  2241.                 changed_height -= (gPenEditorCandidateInputBox.height + 1);
  2242.                 gPenEditorVKCandidate = MMI_TRUE;
  2243.             }
  2244.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_SYMBOL);
  2245.         }
  2246. //KP Jerry add on 2007-3-21 end
  2247. #endif/*__MMI_LANG_SM_CHINESE__*/      //KP Jerry add on 2007-4-16
  2249. //KP Jerry add on 2007-4-16 start
  2250. #ifdef __MMI_LANG_VIETNAMESE__
  2251.         else if (INPUT_MODE_MULTITAP_LOWERCASE_VIETNAMESE == MMI_current_input_mode || 
  2252.                  INPUT_MODE_SMART_LOWERCASE_VIETNAMESE == MMI_current_input_mode)
  2253.         {
  2254.             if (gPenEditorVKCandidate)
  2255.             {
  2256.                 changed_height += gPenEditorCandidateInputBox.height;
  2257.             }
  2258.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_ENGLISH);
  2259.         }
  2260.         else if (INPUT_MODE_MULTITAP_UPPERCASE_VIETNAMESE == MMI_current_input_mode ||
  2261.                  INPUT_MODE_SMART_UPPERCASE_VIETNAMESE == MMI_current_input_mode)
  2262.          {
  2263.             if (gPenEditorVKCandidate)
  2264.             {
  2265.                 changed_height += gPenEditorCandidateInputBox.height;
  2266.             }
  2267.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_ENGLISH_UPPERCASE);
  2268.         }
  2269. #endif
  2271. #ifdef __MMI_LANG_RUSSIAN__
  2272.         else if (INPUT_MODE_MULTITAP_LOWERCASE_RUSSIAN == MMI_current_input_mode || 
  2273.                  INPUT_MODE_SMART_LOWERCASE_RUSSIAN == MMI_current_input_mode)
  2274.         {
  2275.             if (gPenEditorVKCandidate)
  2276.             {
  2277.                 changed_height += gPenEditorCandidateInputBox.height;
  2278.             }
  2279.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_RUSSIAN);
  2280.         }
  2281.         else if (INPUT_MODE_MULTITAP_UPPERCASE_RUSSIAN== MMI_current_input_mode ||
  2282.                  INPUT_MODE_SMART_UPPERCASE_RUSSIAN == MMI_current_input_mode)
  2283.          {
  2284.             if (gPenEditorVKCandidate)
  2285.             {
  2286.                 changed_height += gPenEditorCandidateInputBox.height;
  2287.             }
  2288.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_RUSSIAN_UPPERCASE);
  2289.         }
  2290. #endif
  2292. #ifdef __MMI_LANG_THAI__
  2293.         else if (INPUT_MODE_MULTITAP_THAI == MMI_current_input_mode || 
  2294.                  INPUT_MODE_SMART_THAI == MMI_current_input_mode)
  2295.         {
  2296.             if (gPenEditorVKCandidate)
  2297.             {
  2298.                 changed_height += gPenEditorCandidateInputBox.height;
  2299.             }
  2300.             wgui_setup_virtual_keyboard(GUI_VIRTUAL_KEYBOARD_ENGLISH_UPPERCASE );
  2301.         }
  2302. #endif
  2303. //KP Jerry add on 2007-4-16 end
  2304. //KP Jerry modify on 2007-4-17 end
  2306.         if (gPenEditorCandidateInputBox.height > MMI_virtual_keyboard.height)
  2307.         {
  2308.             changed_height -= gPenEditorCandidateInputBox.height;
  2309.         }
  2310.         else
  2311.         {
  2312.             changed_height -= MMI_virtual_keyboard.height;
  2313.         }
  2314.         gdi_layer_lock_frame_buffer();
  2315.         mmi_pen_editor_resize_content_area(changed_height);
  2316.         if (PEN_EDITOR_INLINE_TEXT == gPenEditorInputBoxType
  2317.             || PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX == gPenEditorInputBoxType)
  2318.         {
  2319.             s32 temp_multiline_height = MMI_multiline_inputbox.height;
  2320.             MMI_BOOL temp_VKCandidate = gPenEditorVKCandidate;
  2321.             gui_virtual_keyboard_language_enum keyboard_type = MMI_virtual_keyboard.lang_type;
  2323.             mmi_pen_editor_vk_list_menu_resize();
  2324.             if (PEN_EDITOR_INLINE_MULTILINE_INPUT_BOX == gPenEditorInputBoxType)
  2325.             {
  2326.                 gui_resize_multi_line_input_box(
  2327.                     &MMI_multiline_inputbox,
  2328.                     MMI_multiline_inputbox.width,
  2329.                     temp_multiline_height);
  2330.                 redraw_fixed_list();
  2331.                 redraw_current_inline_item();
  2332.                 gPenEditorVKCandidate = temp_VKCandidate;
  2333.             }
  2334.             wgui_setup_virtual_keyboard(keyboard_type);
  2335.         }
  2336.         gui_move_single_line_input_box(
  2337.             &gPenEditorCandidateInputBox,
  2338.             gPenEditorCandidateInputBox.x,
  2339.             MMI_virtual_keyboard.y - gPenEditorCandidateInputBox.height - 2);
  2340.         if (gPenEditorVKCandidate)
  2341.         {
  2342.             mmi_pen_editor_hide_candidate_area();
  2343.         }
  2344.         gdi_layer_unlock_frame_buffer();
  2345.         mmi_pen_editor_clear_and_show_virtual_keyboard_area();
  2346.     }
  2347.     /* W05.50 Exclude Virtual Keyboard Area from Handwriting Area */
  2348.     mmi_pen_editor_change_handwriting_area();
  2349. }
  2352. /*****************************************************************************
  2353.  * FUNCTION
  2354.  *  mmi_pen_editor_multi_block_stroke_down_handler
  2355.  * DESCRIPTION
  2356.  *  When receiving the stroke down event, do the related action according to the current situation
  2357.  * PARAMETERS
  2358.  *  pos     [IN]        The position of the stroke down event
  2359.  * RETURNS
  2360.  *  void
  2361.  *****************************************************************************/
  2362. void mmi_pen_editor_multi_block_stroke_down_handler(mmi_pen_point_struct pos)
  2363. {
  2364.     /*----------------------------------------------------------------*/
  2365.     /* Local Variables                                                */
  2366.     /*----------------------------------------------------------------*/
  2367.     int changed_height;
  2368.     S32 active_block = 0;
  2370.     /*----------------------------------------------------------------*/
  2371.     /* Local Variables Initializing                                   */
  2372.     /*----------------------------------------------------------------*/
  2373.     changed_height = 0;
  2375.     /*----------------------------------------------------------------*/
  2376.     /* Code Body                                                      */
  2377.     /*----------------------------------------------------------------*/
  2378.     if (!gPenEditorEnableHandWriting)
  2379.     {
  2380.         MMI_DBG_ASSERT(0);
  2381.         return;
  2382.     }
  2383.     if (g_pen_editor_smart_latin_pre_candidate_length)
  2384.     {
  2385.         mmi_pen_editor_smart_latin_confirm_select();
  2386.         mmi_pen_editor_set_left_soft_key();
  2387.     }
  2388.     if (g_pen_editor_composition_state.candidate_state != PEN_EDITOR_CANDIDATE_OFF)
  2389.     {
  2390.         int change_height = 0;
  2392.         g_pen_editor_composition_state.candidate_state = PEN_EDITOR_CANDIDATE_OFF;
  2393.         change_height += g_pen_editor_composition_input_box.height;
  2394.         mmi_pen_editor_resize_content_area(change_height);
  2395.         mmi_pen_editor_reset_key_sequence(&g_pen_editor_key_sequence);
  2396.     }
  2398.     /* create new layer for stroke through Draw Manager */
  2399.     if (gPenEditorGDIHandler == NULL || *gPenEditorGDIHandler == GDI_ERROR_HANDLE)
  2400.     {
  2401.         gPenEditorStrokeGDIBuffer = (U8*) mmi_frm_scrmem_alloc(handwriting_stroke_layer_mem);
  2402.         MMI_ASSERT(gPenEditorStrokeGDIBuffer);
  2403.         if (GDI_LAYER_SUCCEED != dm_create_layer_using_outside_memory(
  2404.                                     0,
  2405.                                     0,
  2406.                                     UI_device_width,
  2407.                                     UI_device_height,
  2408.                                     &gPenEditorGDIHandler,
  2409.                                     (U8*) gPenEditorStrokeGDIBuffer,
  2410.                                     handwriting_stroke_layer_mem,
  2411.                                     DM_LAYER_TOP))
  2412.         {
  2413.             MMI_ASSERT(0);
  2414.         }
  2415.         gdi_layer_push_and_set_active(*gPenEditorGDIHandler);
  2416.         gdi_layer_set_source_key(TRUE, GDI_COLOR_TRANSPARENT);
  2417.         gdi_layer_clear(GDI_COLOR_TRANSPARENT);
  2418.         gdi_layer_pop_and_restore_active();
  2419.     }
  2421.     /* If the state requires confirm, confirm it directly in this situation// */
  2422.     if (gPenEditorSelectCandidate)
  2423.     {
  2424.         gui_cancel_timer(mmi_pen_editor_confirm_selection);
  2425.         gPenEditorShowVK = MMI_FALSE;
  2426.         mmi_pen_editor_confirm_selection();
  2427.         mmi_pen_editor_hide_candidate_area();
  2428.         mmi_pen_editor_clear_and_show_virtual_keyboard_area();
  2429.     }
  2430.     active_block = mmi_pen_editor_handwriting_check_block(pos);
  2431.     if (g_pen_editor_active_block)
  2432.     {
  2433.         if (g_pen_editor_active_block != active_block)
  2434.         {
  2435.             mmi_pen_editor_handwriting_direct_input();
  2436.         }
  2437.     }
  2438.     g_pen_editor_active_block = active_block;
  2439.     if (!g_pen_editor_active_block)
  2440.     {
  2441.         g_pen_editor_active_block = 0;
  2442.     }
  2443.     /* Clear Virtual Keyboard Area only at the first stroke */
  2444.     if (gPenEditorFirstStroke)
  2445.     {
  2446.         gPenEditorFirstStroke = MMI_FALSE;
  2447.     }
  2448.     gPenEditorShowVK = MMI_TRUE;
  2449.     gPenEditorVKState = PEN_EDITOR_VK_OFF;
  2450.     gPenEditorPreviousPoint.x = pos.x;
  2451.     gPenEditorPreviousPoint.y = pos.y;
  2452. }
  2455. /*****************************************************************************
  2456.  * FUNCTION
  2457.  *  mmi_pen_editor_multi_block_stroke_move_handler
  2458.  * DESCRIPTION
  2459.  *  Draw the stroke when moving the pen in the stroke mode and check the stroke is out of the current block or not.
  2460.  *  If yes, pass the stroke buffer to the handwriting module for recognizing
  2461.  * PARAMETERS
  2462.  *  pos     [IN]        The position of the stroke move event
  2463.  * RETURNS
  2464.  *  void
  2465.  *****************************************************************************/
  2466. void mmi_pen_editor_multi_block_stroke_move_handler(mmi_pen_point_struct pos)
  2467. {
  2468.     /*----------------------------------------------------------------*/
  2469.     /* Local Variables                                                */
  2470.     /*----------------------------------------------------------------*/
  2471.     S32 active_block = 0;
  2473.     /*----------------------------------------------------------------*/
  2474.     /* Code Body                                                      */
  2475.     /*----------------------------------------------------------------*/
  2476.     /* if hand writing is not enabled, it should not go here */
  2477.     if (!gPenEditorEnableHandWriting)
  2478.     {
  2479.         MMI_DBG_ASSERT(0);
  2480.         return;
  2481.     }
  2482.     active_block = mmi_pen_editor_handwriting_check_block(pos);
  2483.     if (active_block)
  2484.     {
  2485.         S32 previous_block = mmi_pen_editor_handwriting_check_block(gPenEditorPreviousPoint);
  2487.         if (active_block == previous_block)
  2488.         {
  2489.             gdi_layer_lock_frame_buffer();
  2490.             gdi_layer_push_and_set_active(*gPenEditorGDIHandler);
  2491.             gdi_layer_push_clip();
  2493.             /* Draw the point of the stroke */
  2494.             gui_line(gPenEditorPreviousPoint.x, gPenEditorPreviousPoint.y, pos.x, pos.y, gPenEditorStrokeColor);
  2495.             gui_line(gPenEditorPreviousPoint.x + 1, gPenEditorPreviousPoint.y, pos.x + 1, pos.y, gPenEditorStrokeColor);
  2496.             gui_line(gPenEditorPreviousPoint.x, gPenEditorPreviousPoint.y + 1, pos.x, pos.y + 1, gPenEditorStrokeColor);
  2497.             gui_line(gPenEditorPreviousPoint.x - 1, gPenEditorPreviousPoint.y, pos.x - 1, pos.y, gPenEditorStrokeColor);
  2498.             gui_line(gPenEditorPreviousPoint.x, gPenEditorPreviousPoint.y - 1, pos.x, pos.y - 1, gPenEditorStrokeColor);
  2500.             gdi_layer_pop_clip();
  2501.             gdi_layer_pop_and_restore_active();
  2502.             gdi_layer_unlock_frame_buffer();
  2504.             gdi_layer_blt_previous(
  2505.                 PEN_MIN(gPenEditorPreviousPoint.x, pos.x) - 1,
  2506.                 PEN_MIN(gPenEditorPreviousPoint.y, pos.y) - 1,
  2507.                 PEN_MAX(gPenEditorPreviousPoint.x, pos.x) + 1,
  2508.                 PEN_MAX(gPenEditorPreviousPoint.y, pos.y) + 1);
  2510.         }
  2511.         gPenEditorPreviousPoint.x = pos.x;
  2512.         gPenEditorPreviousPoint.y = pos.y;
  2513.     }
  2514.     if (g_pen_editor_active_block)
  2515.     {
  2516.         if (g_pen_editor_active_block != active_block)
  2517.         {
  2518.             mmi_pen_editor_handwriting_direct_input();
  2519.             if (active_block)
  2520.             {
  2521.                 gPenEditorFirstStroke = MMI_FALSE;
  2522.             }
  2523.         }
  2524.     }
  2525.     g_pen_editor_active_block = active_block;
  2526.     if (!g_pen_editor_active_block)
  2527.     {
  2528.         gPenEditorVKState = PEN_EDITOR_VK_ON;
  2529.     }
  2530.     else
  2531.     {
  2532.         gPenEditorVKState = PEN_EDITOR_VK_OFF;
  2533.     }
  2534. }
  2536. void mmi_pen_editor_inline_full_screen_redraw_handwriting_area(void)
  2537. {
  2538.     /* W06.05 Fix Background display issue in virtual keyboard */
  2539.     if (PEN_EDITOR_HANDWRITING_STYLE_MULTI_BLOCK == mmi_pen_editor_get_handwriting_style()&&
  2540.         (GUI_VIRTUAL_KEYBOARD_TRAY == MMI_virtual_keyboard.lang_type
  2541.          || GUI_VIRTUAL_KEYBOARD_NUMBER_DOT_TRAY == MMI_virtual_keyboard.lang_type
  2542.          || GUI_VIRTUAL_KEYBOARD_NUMBER_TRAY == MMI_virtual_keyboard.lang_type
  2543.          || GUI_VIRTUAL_KEYBOARD_PHONE_NUMBER == MMI_virtual_keyboard.lang_type))
  2544.     {
  2545.         mmi_pen_editor_draw_handwriting_block();
  2546.     }
  2547.     mmi_pen_editor_clear_and_show_virtual_keyboard_area();
  2548. }
  2549. #endif /* defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__) */