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

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

MTK

开发平台：

C/C++

gui_virtual_keyboard.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  *   gui_virtual_keyboard.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   Virtual keyboard - UI component
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  * -------
  54.  *
  55.  *============================================================================
  56.  *             HISTORY
  57.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  58.  *------------------------------------------------------------------------------
  59.  * removed!
  60.  *
  61.  * removed!
  62.  * removed!
  63.  * removed!
  64.  *
  65.  * removed!
  66.  * removed!
  67.  * removed!
  68.  *
  69.  * removed!
  70.  * removed!
  71.  * removed!
  72.  *
  73.  * removed!
  74.  * removed!
  75.  * removed!
  76.  *
  77.  * removed!
  78.  * removed!
  79.  * removed!
  80.  *
  81.  * removed!
  82.  * removed!
  83.  * removed!
  84.  *
  85.  * removed!
  86.  * removed!
  87.  * removed!
  88.  *
  89.  * removed!
  90.  * removed!
  91.  * removed!
  92.  *
  93.  * removed!
  94.  * removed!
  95.  * removed!
  96.  *
  97.  *------------------------------------------------------------------------------
  98.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  99.  *============================================================================
  100.  ****************************************************************************/
  102. #include "MMI_features.h"
  103. #include "gui_virtual_keyboard.h"
  104. #include "wgui_virtual_keyboard.h"
  105. #include "gui_themes.h"
  106. #include "wgui.h"
  107. #include "wgui_categories_defs.h"
  108. #include "wgui_categories_util.h"       /* get_image() */
  109. #include "DebugInitDef.h"
  111. /*
  112.  * FIXME.
  113.  *
  114.  * 1. Currently we only support one matrix layout per keyboard.
  115.  * 2. Use static memory to avoid out-of-memory in control buffer
  116.  *
  117.  */
  119. extern BOOL r2lMMIFlag;
  121. /***************************************************************************** 
  122. * Define
  123. *****************************************************************************/
  125. #define VKBD_DIFF_HALF(a, b)  ((a) >= (b) ? (((a)-(b))>>1) : 0)
  127. /***************************************************************************** 
  128. * Typedef 
  129. *****************************************************************************/
  131. /***************************************************************************** 
  132. * Local Variable
  133. *****************************************************************************/
  135. /***************************************************************************** 
  136. * Local Function
  137. *****************************************************************************/
  140. /*****************************************************************************
  141.  * FUNCTION
  142.  *  gui_virtual_keyboard_clear_selected_key
  143.  * DESCRIPTION
  144.  *  
  145.  * PARAMETERS
  146.  *  s       [OUT]     
  147.  * RETURNS
  148.  *  void
  149.  *****************************************************************************/
  150. static void gui_virtual_keyboard_clear_selected_key(virtual_keyboard_selection_struct *s)
  151. {
  152.     /*----------------------------------------------------------------*/
  153.     /* Local Variables                                                */
  154.     /*----------------------------------------------------------------*/
  156.     /*----------------------------------------------------------------*/
  157.     /* Code Body                                                      */
  158.     /*----------------------------------------------------------------*/
  159.     s->matrix_index = -1;
  160.     s->matrix_column = -1;
  161.     s->matrix_row = -1;
  162.     s->custom_key_index = -1;
  163.     s->key_width = 0;
  164.     s->key_height = 0;
  165.     s->key_x = 0;
  166.     s->key_y = 0;
  167. }
  170. /*****************************************************************************
  171.  * FUNCTION
  172.  *  gui_virtual_keyboard_check_dead_key
  173.  * DESCRIPTION
  174.  *  
  175.  * PARAMETERS
  176.  *  ch      [IN]        
  177.  * RETURNS
  178.  *  
  179.  *****************************************************************************/
  180. static BOOL gui_virtual_keyboard_check_dead_key(UI_character_type ch)
  181. {
  182.     /*----------------------------------------------------------------*/
  183.     /* Local Variables                                                */
  184.     /*----------------------------------------------------------------*/
  186.     /*----------------------------------------------------------------*/
  187.     /* Code Body                                                      */
  188.     /*----------------------------------------------------------------*/
  189.     switch (ch)
  190.     {
  191.         case 0x60:  /* ` */
  192.         case 0xB4:
  193.         case 0x5E:  /* ^ */
  194.         case 0xA8:
  195.         case 0x7E:  /* ~ */
  196.             return MMI_TRUE;
  197.         default:
  198.             return MMI_FALSE;
  199.     }
  200. }
  203. /*****************************************************************************
  204.  * FUNCTION
  205.  *  gui_virtual_keyboard_show_char_center_align
  206.  * DESCRIPTION
  207.  *  
  208.  * PARAMETERS
  209.  *  ch                  [IN]        
  210.  *  key_x               [IN]        
  211.  *  key_y               [IN]        
  212.  *  key_width           [IN]        
  213.  *  key_height          [IN]        
  214.  *  glyph_width         [OUT]         
  215.  *  glyph_height        [OUT]         
  216.  * RETURNS
  217.  *  void
  218.  *****************************************************************************/
  219. static void gui_virtual_keyboard_show_char_center_align(
  220.                 UI_character_type ch,
  221.                 S32 key_x,
  222.                 S32 key_y,
  223.                 S32 key_width,
  224.                 S32 key_height,
  225.                 S32 *glyph_width,
  226.                 S32 *glyph_height)
  227. {
  228.     /*----------------------------------------------------------------*/
  229.     /* Local Variables                                                */
  230.     /*----------------------------------------------------------------*/
  231.     S32 bbox_x, bbox_y, bbox_width, bbox_height;
  232.     S32 char_x, char_y;
  234.     /*----------------------------------------------------------------*/
  235.     /* Code Body                                                      */
  236.     /*----------------------------------------------------------------*/
  237.     if (ch == (UI_character_type) '_')  /* '_' is special because it will get confused with '-' */
  238.     {
  239.         gui_measure_character(ch, glyph_width, glyph_height);
  240.         char_x = key_x + VKBD_DIFF_HALF(key_width, *glyph_width);
  241.         char_y = key_y + VKBD_DIFF_HALF(key_width, *glyph_height);
  242.     }
  243.     else
  244.     {
  245.         Get_CharBoundingBox(ch, glyph_width, glyph_height, &bbox_x, &bbox_y, &bbox_width, &bbox_height);
  247.         char_x = key_x + VKBD_DIFF_HALF(key_width, bbox_width) - bbox_x;
  248.         char_y = key_y + VKBD_DIFF_HALF(key_height, bbox_height) - bbox_y;
  250.         /* HACK. the number of remaing pixels is odd. */
  251.         /* It is not always correct depending on the baseline of the font database */
  252.         /* The magic number bbox_y + "1" can be modified */
  253.         if (((key_height - bbox_height) & 1) && (bbox_y + 1 > *glyph_height - bbox_height - bbox_y))
  254.         {
  255.             char_y++;
  256.         }
  258.         if (r2lMMIFlag)
  259.         {
  260.             char_x += *glyph_width;
  261.         }
  262.     }
  264.     gui_move_text_cursor(char_x, char_y);
  265.     gui_print_character(ch);
  266. }
  269. /*****************************************************************************
  270.  * FUNCTION
  271.  *  gui_virtual_keyboard_convert_custom_img
  272.  * DESCRIPTION
  273.  *  Convert some image ID of custom key because some images are displayed 
  274.  *  differently in multi-block handwriting
  275.  * PARAMETERS 
  276.  *  v           [IN/OUT]         
  277.  *  id          [IN]        image ID of custom key
  278.  * RETURNS
  279.  *  Converted image id
  280.  *****************************************************************************/
  281. static MMI_ID_TYPE gui_virtual_keyboard_convert_custom_img(virtual_keyboard *v, MMI_ID_TYPE id)
  282. {
  283.     /*----------------------------------------------------------------*/
  284.     /* Local Variables                                                */
  285.     /*----------------------------------------------------------------*/
  287.     /*----------------------------------------------------------------*/
  288.     /* Code Body                                                      */
  289.     /*----------------------------------------------------------------*/
  290.     /* Phone number keyboard layout coexist with multi-block but it has IMG_VKBD_CUSTOM_HIDE key */
  291.     if (!(v->flags & GUI_VKBD_FLAG_MULTI_BLOCK_MODE) ||
  292.         v->lang_type == GUI_VIRTUAL_KEYBOARD_PHONE_NUMBER)
  293.     {
  294.         return id;
  295.     }
  296.     else if (id == IMG_VKBD_CUSTOM_HIDE)
  297.     {
  298.         return IMG_VKBD_CUSTOM_SWITCH_HANDWRITING;
  299.     }
  300.     else if (id == IMG_VKBD_CUSTOM_SHOW)
  301.     {
  302.         return IMG_VKBD_CUSTOM_SWITCH_KEYBOARD;
  303.     }
  304.     else
  305.     {
  306.         return id;
  307.     }
  308. }
  311. /*****************************************************************************
  312.  * FUNCTION
  313.  *  gui_virtual_keyboard_is_key_disabled
  314.  * DESCRIPTION
  315.  *  
  316.  * PARAMETERS
  317.  *  v           [IN/OUT]         
  318.  *  event       [IN]        
  319.  *  ch          [IN]        
  320.  * RETURNS
  321.  *  
  322.  *****************************************************************************/
  323. static MMI_BOOL gui_virtual_keyboard_is_key_disabled(
  324.                     virtual_keyboard *v,
  325.                     gui_virtual_keyboard_pen_enum event,
  326.                     UI_character_type ch)
  327. {
  328.     /*----------------------------------------------------------------*/
  329.     /* Local Variables                                                */
  330.     /*----------------------------------------------------------------*/
  332.     /*----------------------------------------------------------------*/
  333.     /* Code Body                                                      */
  334.     /*----------------------------------------------------------------*/
  335.     if (v->allowed_characters)
  336.     {
  337.         MMI_BOOL disabled = MMI_TRUE;
  339.         /* gui_set_virtual_keyboard_allowed_characters() and 
  340.            gui_set_virtual_board_disable_list() are mutually-exclusive */
  341.         MMI_DBG_ASSERT(v->disabled_chars[0] == 0 && v->disabled_symbols[0] == GUI_VKBD_PEN_NONE);
  343.         switch (event)
  344.         {
  345.                 // TODO: GUI_VKBD_PEN_EUROSYMB is not supported
  346.             case GUI_VKBD_PEN_HIDE:
  347.             case GUI_VKBD_PEN_SHOW:
  348.             case GUI_VKBD_PEN_CAPSLOCK:
  349.             case GUI_VKBD_PEN_BAKSPACE:
  350.             case GUI_VKBD_PEN_DISPLAY_AREA:
  351.                 /* GUI_VKBD_PEN_DISPLAY_AREA is always enabled because it's display only */
  352.                 disabled = MMI_FALSE;
  353.                 break;
  355.             case GUI_VKBD_PEN_NEWLINE:
  356.                 ch = (UI_character_type) 'n';
  357.                 event = GUI_VKBD_PEN_CHAR_I;
  358.                 break;
  360.             case GUI_VKBD_PEN_SPACE:
  361.                 ch = (UI_character_type) ' ';
  362.                 event = GUI_VKBD_PEN_CHAR_I;
  363.                 break;
  365.             case GUI_VKBD_PEN_SYMBPICKER:
  366.             {
  367.                 /* Check existence of non-alphanumeric character */
  368.                 const UI_character_type *pch = v->allowed_characters;
  369.                 UI_character_type tmp;
  371.                 while ((tmp = *pch++) != 0)
  372.                 {
  373.                     if (tmp == (UI_character_type) '\' ||  /* Assume the next character to be punctuation */
  374.                         !(tmp == (UI_character_type) '-' ||
  375.                           (tmp >= (UI_character_type) 'a' && tmp <= (UI_character_type) 'z') ||
  376.                           (tmp >= (UI_character_type) 'A' && tmp <= (UI_character_type) 'Z') ||
  377.                           (tmp >= (UI_character_type) '0' && tmp <= (UI_character_type) '9')))
  378.                     {
  379.                         disabled = MMI_FALSE;
  380.                         break;
  381.                     }
  382.                 }
  383.                 break;
  384.             }
  385.         }
  387.         if (event == GUI_VKBD_PEN_CHAR_I)
  388.         {
  389.             const UI_character_type *pch = v->allowed_characters;
  390.             S32 idx;
  392.             for (idx = 0; pch[idx]; idx++)
  393.             {
  394.                 UI_character_type tmp = pch[idx];
  396.                 if (tmp == (UI_character_type) '-' && idx > 0 && pch[idx + 1])
  397.                 {
  398.                     if (ch >= pch[idx - 1] && ch <= pch[idx + 1])
  399.                     {
  400.                         disabled = MMI_FALSE;
  401.                         break;
  402.                     }
  403.                     idx++;
  404.                 }
  405.                 else
  406.                 {
  407.                     if (tmp == (UI_character_type) '\' && pch[idx + 1])
  408.                     {
  409.                         tmp = pch[++idx];
  410.                     }
  412.                     if (tmp == ch)
  413.                     {
  414.                         disabled = MMI_FALSE;
  415.                         break;
  416.                     }
  417.                 }
  418.             }
  419.         }
  421.         return disabled;
  422.     }
  423.     else
  424.     {
  425.         if (event == GUI_VKBD_PEN_CHAR_I)
  426.         {
  427.             UI_character_type *ptr = v->disabled_chars, tmp;
  429.             if (ch == 0)
  430.             {
  431.                 return MMI_TRUE;
  432.             }
  434.             while ((tmp = *ptr++) != 0)
  435.             {
  436.                 if (tmp == ch)
  437.                 {
  438.                     return MMI_TRUE;
  439.                 }
  440.             }
  442.             return MMI_FALSE;
  443.         }
  444.         else if (event == GUI_VKBD_PEN_NONE)
  445.         {
  446.             return MMI_TRUE;
  447.         }
  448.         else
  449.         {
  450.             gui_virtual_keyboard_pen_enum *ptr = v->disabled_symbols, tmp;
  452.             while ((tmp = *ptr++) != GUI_VKBD_PEN_NONE)
  453.             {
  454.                 if (tmp == event)
  455.                 {
  456.                     return MMI_TRUE;
  457.                 }
  458.             }
  460.             return MMI_FALSE;
  461.         }
  462.     }
  463. }
  465. #ifdef __MMI_TOUCH_SCREEN__
  467. /* Return > 0 if dead key sequence is completed */
  470. /*****************************************************************************
  471.  * FUNCTION
  472.  *  gui_get_dead_key_symbol
  473.  * DESCRIPTION
  474.  *  
  475.  * PARAMETERS
  476.  *  lang_type           [IN]        
  477.  *  input_string        [IN]         
  478.  *  input_len           [IN]        
  479.  * RETURNS
  480.  *  
  481.  *****************************************************************************/
  482. UI_character_type gui_get_dead_key_symbol(
  483.                     gui_virtual_keyboard_language_enum lang_type,
  484.                     U16 *input_string,
  485.                     S32 input_len)
  486. {
  487.     /*----------------------------------------------------------------*/
  488.     /* Local Variables                                                */
  489.     /*----------------------------------------------------------------*/
  490.     S32 i;
  491.     S32 n_entry;
  492.     const gui_keyboard_language_struct *lang;
  493.     const gui_dead_key_map_struct *t;
  494.     const gui_dead_key_symbol_struct *d;
  496.     /*----------------------------------------------------------------*/
  497.     /* Code Body                                                      */
  498.     /*----------------------------------------------------------------*/
  499.     lang = MMI_virtual_keyboard_language_map[lang_type].virtual_keyboard_language;
  501.     if (!lang->enable_dead_key)
  502.     {
  503.         return 0;
  504.     }
  506.     t = &gui_dead_key_symbol_table[lang_type];
  508.     n_entry = t->nentry;
  510.     d = &t->dead_key_symbol[0];
  511.     for (i = 0; i < n_entry; i++)
  512.     {
  513.         if (input_len != d->nInputLen)
  514.         {
  515.             continue;
  516.         }
  518.         if (memcmp(d->input_char, input_string, d->nInputLen * 2) == 0)
  519.         {
  520.             return d->output_char;
  521.         }
  522.         d++;
  523.     }
  525.     return 0;
  526. }
  529. /*****************************************************************************
  530.  * FUNCTION
  531.  *  gui_virtual_keyboard_get_selected_key
  532.  * DESCRIPTION
  533.  *  
  534.  * PARAMETERS
  535.  *  v       [IN/OUT]     
  536.  *  ch      [OUT]     
  537.  *  evt     [OUT]     
  538.  * RETURNS
  539.  *  
  540.  *****************************************************************************/
  541. static BOOL gui_virtual_keyboard_get_selected_key(
  542.                 virtual_keyboard *v,
  543.                 UI_character_type *ch,
  544.                 gui_virtual_keyboard_pen_enum *evt)
  545. {
  546.     /*----------------------------------------------------------------*/
  547.     /* Local Variables                                                */
  548.     /*----------------------------------------------------------------*/
  549.     const gui_keyboard_language_struct *lang;
  550.     virtual_keyboard_selection_struct *s = &v->selected_key;
  552.     /*----------------------------------------------------------------*/
  553.     /* Code Body                                                      */
  554.     /*----------------------------------------------------------------*/
  555.     *ch = 0;
  556.     *evt = GUI_VKBD_PEN_NONE;
  558.     lang = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_language;
  560.     if (s->matrix_index < 0 && s->custom_key_index < 0)
  561.     {
  562.         return MMI_FALSE;
  563.     }
  565.     if (s->matrix_index >= 0)
  566.     {
  567.         MMI_DBG_ASSERT(s->matrix_column >= 0 && s->matrix_row >= 0);
  568.         *evt = GUI_VKBD_PEN_CHAR_I;
  569.         *ch = lang->matrix_string[s->matrix_row][s->matrix_column];
  570.     }
  571.     else
  572.     {
  573.         *evt = lang->custom_key_type[s->custom_key_index];
  574.         *ch = lang->custom_string[s->custom_key_index];
  575.     }
  577.     MMI_DBG_ASSERT(!*ch || *evt == GUI_VKBD_PEN_CHAR_I);
  578.     return MMI_TRUE;
  579. }
  582. /*****************************************************************************
  583.  * FUNCTION
  584.  *  gui_virtual_keyboard_translate_dead_key
  585.  * DESCRIPTION
  586.  *  
  587.  * PARAMETERS
  588.  *  v       [IN/OUT]     
  589.  *  ch      [IN/OUT]     
  590.  *  evt     [IN/OUT]     
  591.  * RETURNS
  592.  *  void
  593.  *****************************************************************************/
  594. static void gui_virtual_keyboard_translate_dead_key(
  595.                 virtual_keyboard *v,
  596.                 UI_character_type *ch,
  597.                 gui_virtual_keyboard_pen_enum *evt)
  598. {
  599.     /*----------------------------------------------------------------*/
  600.     /* Local Variables                                                */
  601.     /*----------------------------------------------------------------*/
  602.     const gui_keyboard_language_struct *lang;
  604.     /*----------------------------------------------------------------*/
  605.     /* Code Body                                                      */
  606.     /*----------------------------------------------------------------*/
  607.     lang = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_language;
  609.     if (lang->enable_dead_key)
  610.     {
  611.         if (*evt == GUI_VKBD_PEN_CHAR_I)
  612.         {
  613.             if (gui_virtual_keyboard_check_dead_key(*ch))
  614.             {
  615.                 v->dead_key_input[0] = *ch;
  616.                 *ch = 0;
  617.                 *evt = GUI_VKBD_PEN_DEAD_KEY;
  618.             }
  619.             else if (v->dead_key_input[0])
  620.             {
  621.                 /* Only two key combination is currently supported */
  622.                 UI_character_type ret;
  624.                 v->dead_key_input[1] = *ch;
  625.                 if ((ret = gui_get_dead_key_symbol(v->lang_type, v->dead_key_input, 2)) != 0)
  626.                 {
  627.                     *ch = ret;
  628.                 }
  629.                 /* Otherwise, use the original key */
  631.                 v->dead_key_input[0] = 0;
  632.             }
  633.         }
  634.         else
  635.         {
  636.             v->dead_key_input[0] = 0;
  637.         }
  638.     }
  639. }
  642. /*****************************************************************************
  643.  * FUNCTION
  644.  *  gui_virtual_keyboard_clear_dead_key
  645.  * DESCRIPTION
  646.  *  
  647.  * PARAMETERS
  648.  *  v       [IN/OUT]     
  649.  * RETURNS
  650.  *  void
  651.  *****************************************************************************/
  652. static void gui_virtual_keyboard_clear_dead_key(virtual_keyboard *v)
  653. {
  654.     /*----------------------------------------------------------------*/
  655.     /* Local Variables                                                */
  656.     /*----------------------------------------------------------------*/
  658.     /*----------------------------------------------------------------*/
  659.     /* Code Body                                                      */
  660.     /*----------------------------------------------------------------*/
  661.     v->dead_key_input[0] = 0;
  662. }
  665. /*****************************************************************************
  666.  * FUNCTION
  667.  *  gui_virtual_keyboard_cache_and_show_selected_key
  668.  * DESCRIPTION
  669.  *  
  670.  * PARAMETERS
  671.  *  v       [IN/OUT]     
  672.  * RETURNS
  673.  *  void
  674.  *****************************************************************************/
  675. static void gui_virtual_keyboard_cache_and_show_selected_key(virtual_keyboard *v)
  676. {
  677.     /*----------------------------------------------------------------*/
  678.     /* Local Variables                                                */
  679.     /*----------------------------------------------------------------*/
  680.     S32 x1, x2, y1, y2;
  681.     S32 glyph_width, glyph_height;
  682.     virtual_keyboard_selection_struct *s;
  683.     const gui_keyboard_language_struct *lang;
  684.     UI_character_type ch = 0;
  685.     PU8 img = NULL;
  687.     /*----------------------------------------------------------------*/
  688.     /* Code Body                                                      */
  689.     /*----------------------------------------------------------------*/
  690.     lang = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_language;
  691.     s = &v->selected_key;
  693.     MMI_DBG_ASSERT(s->custom_key_index >= 0 || s->matrix_index >= 0);
  695.     if (s->custom_key_index >= 0 && lang->custom_key_type[s->custom_key_index] == GUI_VKBD_PEN_DISPLAY_AREA)
  696.     {
  697.         /* We do not select Display Area. Furthermore, it costs too much memory to cache the area */
  698.         return;
  699.     }
  701.     x1 = s->key_x;
  702.     y1 = s->key_y;
  703.     x2 = x1 + s->key_width - 1;
  704.     y2 = y1 + s->key_height - 1;
  706.     /* Use a fixed size to avoid running out of certain control buffer bucket size */
  707.     MMI_DBG_ASSERT((((S32) s->key_width * s->key_height * gdi_layer_get_bit_per_pixel() + 7) >> 3) <=
  708.                    MMI_virtual_keyboard_bitmap_cache_size);
  709.     v->selected_key_cached = 1;
  710. #if 1
  711.     {
  712.         /* Workaround. We might not be able allocate large control buffer */
  713.     #if defined(__MMI_MAIN_BASE_LAYER_FORMAT__) && (__MMI_MAIN_BASE_LAYER_FORMAT__ == GDI_COLOR_FORMAT_32)
  714.         static char bitmap_buffer[5000];    
  715.     #else
  716.         static char bitmap_buffer[2500];
  717.     #endif
  719.         MMI_ASSERT(MMI_virtual_keyboard_bitmap_cache_size < sizeof(bitmap_buffer));
  720.         v->selected_key_bitmap.buf_ptr = (U8*) bitmap_buffer;
  721.     }
  722. #else /* 1 */ 
  723. /* under construction !*/
  724. #endif /* 1 */ 
  726.     gui_lock_double_buffer();
  728.     gdi_layer_push_clip();
  730.     gdi_layer_set_clip(x1, y1, x2, y2);
  731.     gdi_image_cache_bmp_get(x1, y1, x2, y2, &v->selected_key_bitmap);
  733.     gui_draw_filled_area(x1 + 1, y1 + 1, x2 - 1, y2 - 1, v->keyboard_theme->key_down_filler);
  735.     if (s->matrix_index >= 0)
  736.     {
  737.         ch = lang->matrix_string[s->matrix_row][s->matrix_column];
  738.     }
  739.     else if (s->custom_key_index >= 0 && lang->custom_string[s->custom_key_index])
  740.     {
  741.         ch = lang->custom_string[s->custom_key_index];
  742.     }
  743.     else
  744.     {
  745.         img = get_image(gui_virtual_keyboard_convert_custom_img(v, lang->custom_key_image[s->custom_key_index]));
  746.     }
  748.     if (ch)
  749.     {
  750.         gui_set_font(v->keyboard_theme->text_font);
  751.         gui_set_text_color(v->keyboard_theme->key_down_text_color);
  753.         gui_virtual_keyboard_show_char_center_align(
  754.             ch,
  755.             s->key_x,
  756.             s->key_y,
  757.             s->key_width,
  758.             s->key_height,
  759.             &glyph_width,
  760.             &glyph_height);
  761.     }
  763.     if (img)
  764.     {
  765.         gui_measure_image(img, &glyph_width, &glyph_height);
  766.         gui_show_image(
  767.             s->key_x + VKBD_DIFF_HALF(s->key_width, glyph_width),
  768.             s->key_y + VKBD_DIFF_HALF(s->key_height, glyph_height),
  769.             img);
  770.     }
  772.     gdi_layer_pop_clip();
  774.     gui_unlock_double_buffer();
  775.     gui_BLT_double_buffer(x1, y1, x2, y2);
  776. }
  779. /*****************************************************************************
  780.  * FUNCTION
  781.  *  gui_virtual_keyboard_show_unselect_key_from_cache
  782.  * DESCRIPTION
  783.  *  
  784.  * PARAMETERS
  785.  *  v       [IN/OUT]     
  786.  * RETURNS
  787.  *  void
  788.  *****************************************************************************/
  789. static void gui_virtual_keyboard_show_unselect_key_from_cache(virtual_keyboard *v)
  790. {
  791.     /*----------------------------------------------------------------*/
  792.     /* Local Variables                                                */
  793.     /*----------------------------------------------------------------*/
  794.     S16 x1, x2, y1, y2;
  796.     /*----------------------------------------------------------------*/
  797.     /* Code Body                                                      */
  798.     /*----------------------------------------------------------------*/
  799.     if (!v->selected_key_cached)
  800.     {
  801.         return;
  802.     }
  804.     x1 = v->selected_key.key_x;
  805.     y1 = v->selected_key.key_y;
  806.     x2 = x1 + v->selected_key.key_width - 1;
  807.     y2 = y1 + v->selected_key.key_height - 1;
  809.     gui_lock_double_buffer();
  810.     gdi_layer_push_clip();
  811.     gdi_layer_set_clip(x1, y1, x2, y2);
  812.     gdi_image_cache_bmp_draw(x1, y1, &v->selected_key_bitmap);
  813.     gdi_layer_pop_clip();
  814.     gui_unlock_double_buffer();
  815.     gui_BLT_double_buffer(x1, y1, x2, y2);
  817.     /* gui_free(v->selected_key_bitmap.buf_ptr); */
  818.     v->selected_key_bitmap.buf_ptr = NULL;
  819.     v->selected_key_cached = 0;
  820. }
  823. /*****************************************************************************
  824.  * FUNCTION
  825.  *  gui_virtual_keyboard_translate_pen_position
  826.  * DESCRIPTION
  827.  *  
  828.  * PARAMETERS
  829.  *  v       [IN/OUT]         
  830.  *  x       [IN]        
  831.  *  y       [IN]        
  832.  *  s       [OUT]         
  833.  * RETURNS
  834.  *  
  835.  *****************************************************************************/
  836. static BOOL gui_virtual_keyboard_translate_pen_position(
  837.                 virtual_keyboard *v,
  838.                 S16 x,
  839.                 S16 y,
  840.                 virtual_keyboard_selection_struct *s)
  841. {
  842.     /*----------------------------------------------------------------*/
  843.     /* Local Variables                                                */
  844.     /*----------------------------------------------------------------*/
  845.     const gui_keyboard_layout_struct *layout;
  846.     S32 i;
  848.     /*----------------------------------------------------------------*/
  849.     /* Code Body                                                      */
  850.     /*----------------------------------------------------------------*/
  851.     layout = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_layout;
  853.     gui_virtual_keyboard_clear_selected_key(s);
  855.     for (i = 0; i < layout->n_matrix_key_layout; i++)
  856.     {
  857.         const gui_matrix_key_layout_struct *matrix;
  858.         S32 matrix_x, matrix_y;
  860.         matrix = &layout->matrix_layout[i];
  861.         matrix_x = v->x + matrix->x;
  862.         matrix_y = v->y + matrix->y;
  863.         if (PEN_CHECK_BOUND(x, y, matrix_x, matrix_y, matrix->width, matrix->height))
  864.         {
  865.             s->matrix_index = i;
  867.             s->matrix_column = (x - matrix_x) / (matrix->key_width + matrix->horizontal_key_gap);
  868.             if (s->matrix_column >= matrix->n_columns)
  869.             {
  870.                 s->matrix_column = matrix->n_columns - 1;
  871.             }
  873.             s->matrix_row = (y - matrix_y) / (matrix->key_height + matrix->vertical_key_gap);
  874.             if (s->matrix_row >= matrix->n_rows)
  875.             {
  876.                 s->matrix_row = matrix->n_rows - 1;
  877.             }
  879.             s->key_width = matrix->key_width;
  880.             s->key_height = matrix->key_height;
  881.             s->key_x = matrix_x + s->matrix_column * (matrix->key_width + matrix->horizontal_key_gap);
  882.             s->key_y = matrix_y + s->matrix_row * (matrix->key_height + matrix->vertical_key_gap);
  883.             return MMI_TRUE;
  884.         }
  885.     }
  887.     for (i = 0; i < layout->n_custom_keys; i++)
  888.     {
  889.         const gui_custom_key_layout_struct *custom_key;
  890.         S32 custom_key_x, custom_key_y;
  892.         custom_key = &layout->custom_keys[i];
  893.         custom_key_x = v->x + custom_key->x;
  894.         custom_key_y = v->y + custom_key->y;
  896.         if (PEN_CHECK_BOUND(x, y, custom_key_x, custom_key_y, custom_key->key_width, custom_key->key_height))
  897.         {
  898.             s->custom_key_index = i;
  900.             s->key_width = custom_key->key_width;
  901.             s->key_height = custom_key->key_height;
  902.             s->key_x = custom_key_x;
  903.             s->key_y = custom_key_y;
  904.             return MMI_TRUE;
  905.         }
  906.     }
  908.     return MMI_FALSE;
  909. }
  911. #endif /* __MMI_TOUCH_SCREEN__ */ 
  913. /***************************************************************************** 
  914. * Global Variable
  915. *****************************************************************************/
  916. UI_virtual_keyboard_theme *current_virtual_keyboard_theme = NULL;
  918. /***************************************************************************** 
  919. * Global Function
  920. *****************************************************************************/
  923. /*****************************************************************************
  924.  * FUNCTION
  925.  *  gui_set_virtual_keyboard_current_theme
  926.  * DESCRIPTION
  927.  *  Applies the current theme for virtual keyboard.
  928.  * PARAMETERS
  929.  *  v       [IN/OUT]        Is the virtual keyboard pointer
  930.  * RETURNS
  931.  *  void
  932.  *****************************************************************************/
  933. void gui_set_virtual_keyboard_current_theme(virtual_keyboard *v)
  934. {
  935.     /*----------------------------------------------------------------*/
  936.     /* Local Variables                                                */
  937.     /*----------------------------------------------------------------*/
  939.     /*----------------------------------------------------------------*/
  940.     /* Code Body                                                      */
  941.     /*----------------------------------------------------------------*/
  942.     MMI_DBG_ASSERT(current_virtual_keyboard_theme);
  943.     v->keyboard_theme = current_virtual_keyboard_theme;
  944.     v->keyboard_theme->flags |= current_virtual_keyboard_theme->flags;
  945. }
  948. /*****************************************************************************
  949.  * FUNCTION
  950.  *  gui_set_virtual_keyboard_theme
  951.  * DESCRIPTION
  952.  *  Applies the current theme for virtual keyboard.
  953.  * PARAMETERS
  954.  *  v       [IN/OUT]        Is the virtual keyboard pointer
  955.  *  t       [IN]         
  956.  * RETURNS
  957.  *  void
  958.  *****************************************************************************/
  959. void gui_set_virtual_keyboard_theme(virtual_keyboard *v, UI_virtual_keyboard_theme *t)
  960. {
  961.     /*----------------------------------------------------------------*/
  962.     /* Local Variables                                                */
  963.     /*----------------------------------------------------------------*/
  965.     /*----------------------------------------------------------------*/
  966.     /* Code Body                                                      */
  967.     /*----------------------------------------------------------------*/
  968.     MMI_DBG_ASSERT(t);
  969.     v->keyboard_theme = t;
  970.     v->keyboard_theme->flags |= t->flags;
  971. }
  974. /*****************************************************************************
  975.  * FUNCTION
  976.  *  gui_create_virtual_keyboard
  977.  * DESCRIPTION
  978.  *  Create virtual keyboard object
  979.  * PARAMETERS
  980.  *  v               [IN/OUT]    Is the virtual keyboard object
  981.  *  x               [IN]        Is the left-top cornerd
  982.  *  y               [IN]        Is the left-top cornerd
  983.  *  lang_type       [IN]        Is language type to be used for the keyboard
  984.  * RETURNS
  985.  *  void
  986.  *****************************************************************************/
  987. void gui_create_virtual_keyboard(virtual_keyboard *v, S16 x, S16 y, gui_virtual_keyboard_language_enum lang_type)
  988. {
  989.     /*----------------------------------------------------------------*/
  990.     /* Local Variables                                                */
  991.     /*----------------------------------------------------------------*/
  993.     /*----------------------------------------------------------------*/
  994.     /* Code Body                                                      */
  995.     /*----------------------------------------------------------------*/
  996.     v->x = x;
  997.     v->y = y;
  998.     v->width = MMI_virtual_keyboard_language_map[lang_type].virtual_keyboard_layout->width;
  999.     v->height = MMI_virtual_keyboard_language_map[lang_type].virtual_keyboard_layout->height;
  1000.     v->lang_type = lang_type;
  1001.     v->flags = 0;
  1002.     v->allowed_characters = NULL;
  1003.     v->disp_area_text[0] = (UI_character_type) '';
  1004.     v->disabled_chars[0] = (UI_character_type) '';
  1005.     v->disabled_symbols[0] = GUI_VKBD_PEN_NONE;
  1006.     gui_set_virtual_keyboard_current_theme(v);
  1008.     memset(v->dead_key_input, 0, sizeof(v->dead_key_input));
  1010.     gui_virtual_keyboard_clear_selected_key(&v->selected_key);
  1011.     v->selected_key_bitmap.buf_ptr = NULL;
  1012.     v->selected_key_cached = 0;
  1013. }
  1016. /*****************************************************************************
  1017.  * FUNCTION
  1018.  *  gui_move_virtual_keyboard
  1019.  * DESCRIPTION
  1020.  *  Move the virtual keyboard
  1021.  * PARAMETERS
  1022.  *  v       [IN/OUT]    Is the virtual keyboard object
  1023.  *  x       [IN]        Is the left-top cornerd
  1024.  *  y       [IN]        Is the left-top cornerd
  1025.  * RETURNS
  1026.  *  void
  1027.  *****************************************************************************/
  1028. void gui_move_virtual_keyboard(virtual_keyboard *v, S16 x, S16 y)
  1029. {
  1030.     /*----------------------------------------------------------------*/
  1031.     /* Local Variables                                                */
  1032.     /*----------------------------------------------------------------*/
  1034.     /*----------------------------------------------------------------*/
  1035.     /* Code Body                                                      */
  1036.     /*----------------------------------------------------------------*/
  1037.     v->x = x;
  1038.     v->y = y;
  1039. }
  1042. /*****************************************************************************
  1043.  * FUNCTION
  1044.  *  gui_show_virtual_keyboard
  1045.  * DESCRIPTION
  1046.  *  Show the virtual keyboard
  1047.  * PARAMETERS
  1048.  *  v       [IN/OUT]        Is the virtual keyboard object
  1049.  * RETURNS
  1050.  *  void
  1051.  *****************************************************************************/
  1052. void gui_show_virtual_keyboard(virtual_keyboard *v)
  1053. {
  1054.     /*----------------------------------------------------------------*/
  1055.     /* Local Variables                                                */
  1056.     /*----------------------------------------------------------------*/
  1057.     S16 x1, y1, x2, y2;
  1058.     S32 glyph_width, glyph_height;
  1059.     UI_character_type key_char;
  1060.     S16 key_width, key_height;
  1061.     S16 key_x, key_y;
  1062.     const gui_keyboard_layout_struct *layout;
  1063.     const gui_keyboard_language_struct *lang;
  1064.     S16 i, j, k;
  1065.     BOOL enable_dead_key;
  1067.     /*----------------------------------------------------------------*/
  1068.     /* Code Body                                                      */
  1069.     /*----------------------------------------------------------------*/
  1070.     x1 = v->x;
  1071.     y1 = v->y;
  1072.     x2 = v->x + v->width - 1;
  1073.     y2 = v->y + v->height - 1;
  1075.     layout = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_layout;
  1076.     lang = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_language;
  1078.     enable_dead_key = lang->enable_dead_key;
  1080.     gui_push_clip();
  1081.     gui_push_text_clip();
  1082.     gui_set_clip(x1, y1, x2, y2);
  1083.     gui_set_text_clip(x1, y1, x2, y2);
  1085.     gui_show_image(x1, y1, (PU8) get_image(layout->ImageId));
  1087.     for (k = 0; k < layout->n_matrix_key_layout; k++)
  1088.     {
  1089.         S16 horizontal_text_gap, vertical_text_gap;
  1090.         S16 n_matrix_column, n_matrix_row;
  1091.         const gui_matrix_key_layout_struct *matrix;
  1092.         const UI_character_type *matrix_string;
  1094.         matrix = &layout->matrix_layout[k];
  1095.         horizontal_text_gap = matrix->horizontal_key_gap;
  1096.         vertical_text_gap = matrix->vertical_key_gap;
  1098.         n_matrix_column = matrix->n_columns;
  1099.         n_matrix_row = matrix->n_rows;
  1101.         key_x = v->x + matrix->x;
  1102.         key_y = v->y + matrix->y;
  1103.         key_width = matrix->key_width;
  1104.         key_height = matrix->key_height;
  1106.         gui_set_font(v->keyboard_theme->text_font);
  1107.         gui_set_text_color(v->keyboard_theme->key_up_text_color);
  1109.         for (i = 0; i < n_matrix_row; i++)
  1110.         {
  1111.             matrix_string = lang->matrix_string[i];
  1112.             for (j = 0; j < n_matrix_column; j++)
  1113.             {
  1114.                 BOOL restore_text_color = MMI_FALSE;
  1116.                 key_char = matrix_string[j];
  1117.                 if (enable_dead_key && gui_virtual_keyboard_check_dead_key(key_char))
  1118.                 {
  1119.                     gui_set_text_color(v->keyboard_theme->dead_key_up_text_color);
  1120.                     restore_text_color = MMI_TRUE;
  1121.                 }
  1122.                 gui_virtual_keyboard_show_char_center_align(
  1123.                     key_char,
  1124.                     key_x,
  1125.                     key_y,
  1126.                     key_width,
  1127.                     key_height,
  1128.                     &glyph_width,
  1129.                     &glyph_height);
  1130.                 if (restore_text_color)
  1131.                 {
  1132.                     gui_set_text_color(v->keyboard_theme->key_up_text_color);
  1133.                 }
  1135.                 if (gui_virtual_keyboard_is_key_disabled(v, GUI_VKBD_PEN_CHAR_I, key_char))
  1136.                 {
  1137.                     gui_greyscale_rectangle(
  1138.                         key_x,
  1139.                         key_y,
  1140.                         key_x + key_width - 1,
  1141.                         key_y + key_height - 1,
  1142.                         MMI_VKBD_GRAYSCALE_VALUE,
  1143.                         MMI_BG_GREYSCALE_BLACK_VALUE);
  1144.                 }
  1146.                 key_x += horizontal_text_gap + key_width;
  1147.             }
  1148.             key_x = v->x + matrix->x;
  1149.             key_y += vertical_text_gap + key_height;
  1150.         }
  1151.     }
  1153.     for (i = 0; i < layout->n_custom_keys; i++)
  1154.     {
  1155.         PU8 custom_image;
  1157.         key_x = v->x + layout->custom_keys[i].x;
  1158.         key_y = v->y + layout->custom_keys[i].y;
  1159.         key_width = layout->custom_keys[i].key_width;
  1160.         key_height = layout->custom_keys[i].key_height;
  1161.         key_char = lang->custom_string[i];
  1163.         if (lang->custom_key_type[i] == GUI_VKBD_PEN_DISPLAY_AREA)
  1164.         {
  1165.             gui_set_text_color(v->keyboard_theme->disp_area_text_color);
  1166.             gui_measure_string((UI_string_type) v->disp_area_text, &glyph_width, &glyph_height);
  1167.             gui_move_text_cursor(
  1168.                 key_x + VKBD_DIFF_HALF(key_width, glyph_width),
  1169.                 key_y + VKBD_DIFF_HALF(key_height, glyph_height));
  1170.             gui_print_text((UI_string_type) v->disp_area_text);
  1172.             /* Restore text color */
  1173.             gui_set_text_color(v->keyboard_theme->key_up_text_color);
  1174.         }
  1175.         else if (!key_char)
  1176.         {
  1177.             custom_image = get_image(gui_virtual_keyboard_convert_custom_img(v, lang->custom_key_image[i]));
  1178.             gui_measure_image(custom_image, &glyph_width, &glyph_height);
  1179.             gui_show_image(
  1180.                 key_x + VKBD_DIFF_HALF(key_width, glyph_width),
  1181.                 key_y + VKBD_DIFF_HALF(key_height, glyph_height),
  1182.                 custom_image);
  1183.         }
  1184.         else
  1185.         {
  1186.             BOOL restore_text_color = MMI_FALSE;
  1188.             if (enable_dead_key && gui_virtual_keyboard_check_dead_key(key_char))
  1189.             {
  1190.                 gui_set_text_color(v->keyboard_theme->dead_key_up_text_color);
  1191.                 restore_text_color = MMI_TRUE;
  1192.             }
  1193.             gui_virtual_keyboard_show_char_center_align(
  1194.                 key_char,
  1195.                 key_x,
  1196.                 key_y,
  1197.                 key_width,
  1198.                 key_height,
  1199.                 &glyph_width,
  1200.                 &glyph_height);
  1201.             if (restore_text_color)
  1202.             {
  1203.                 gui_set_text_color(v->keyboard_theme->key_up_text_color);
  1204.             }
  1205.         }
  1207.         if (gui_virtual_keyboard_is_key_disabled(v, lang->custom_key_type[i], key_char))
  1208.         {
  1209.             gui_greyscale_rectangle(
  1210.                 key_x,
  1211.                 key_y,
  1212.                 key_x + key_width - 1,
  1213.                 key_y + key_height - 1,
  1214.                 MMI_VKBD_GRAYSCALE_VALUE,
  1215.                 MMI_BG_GREYSCALE_BLACK_VALUE);
  1216.         }
  1217.     }
  1219.     gui_pop_clip();
  1220.     gui_pop_text_clip();
  1221. }
  1224. /*****************************************************************************
  1225.  * FUNCTION
  1226.  *  gui_set_virtual_keyboard_display_area
  1227.  * DESCRIPTION
  1228.  *  Update text displayed on display area
  1229.  * PARAMETERS
  1230.  *  v           [IN/OUT]        
  1231.  *  string      [IN]        String to be displayed in display area
  1232.  *  redraw      [IN]        Whether to redraw the keyboard
  1233.  * RETURNS
  1234.  *  void
  1235.  *****************************************************************************/
  1236. void gui_set_virtual_keyboard_display_area(virtual_keyboard *v, const U8 *string, BOOL redraw)
  1237. {
  1238.     /*----------------------------------------------------------------*/
  1239.     /* Local Variables                                                */
  1240.     /*----------------------------------------------------------------*/
  1241.     const gui_keyboard_layout_struct *layout;
  1242.     const gui_keyboard_language_struct *lang;
  1243.     S32 x1, y1, x2, y2, glyph_width, glyph_height;
  1244.     S32 i;
  1246.     /*----------------------------------------------------------------*/
  1247.     /* Code Body                                                      */
  1248.     /*----------------------------------------------------------------*/
  1249.     UCS2Strncpy((S8*) v->disp_area_text, (const S8*)string, MMI_VKBD_MAX_DISPLAY_AREA_TEXT_LEN);
  1251.     /* redraw the area only */
  1252.     if (redraw)
  1253.     {
  1254.         layout = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_layout;
  1255.         lang = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_language;
  1257.         gui_set_font(v->keyboard_theme->text_font);
  1258.         for (i = 0; i < layout->n_custom_keys; i++)
  1259.         {
  1260.             if (lang->custom_key_type[i] == GUI_VKBD_PEN_DISPLAY_AREA)
  1261.             {
  1262.                 const gui_custom_key_layout_struct *custom_key = &layout->custom_keys[i];
  1264.                 x1 = v->x + custom_key->x;
  1265.                 y1 = v->y + custom_key->y;
  1266.                 x2 = x1 + custom_key->key_width - 1;
  1267.                 y2 = y1 + custom_key->key_height - 1;
  1269.                 gui_lock_double_buffer();
  1270.                 gui_push_clip();
  1271.                 gui_push_text_clip();
  1272.                 gui_set_clip(x1, y1, x2, y2);
  1273.                 gui_set_text_clip(x1, y1, x2, y2);
  1275.                 gui_show_image(x1, y1, get_image(gui_virtual_keyboard_convert_custom_img(v, lang->custom_key_image[i])));
  1276.                 gui_set_text_color(v->keyboard_theme->disp_area_text_color);
  1277.                 gui_measure_string((UI_string_type) v->disp_area_text, &glyph_width, &glyph_height);
  1278.                 gui_move_text_cursor(
  1279.                     x1 + VKBD_DIFF_HALF(custom_key->key_width, glyph_width),
  1280.                     y1 + VKBD_DIFF_HALF(custom_key->key_height, glyph_height));
  1281.                 gui_print_text((UI_string_type) v->disp_area_text);
  1283.                 gui_pop_clip();
  1284.                 gui_pop_text_clip();
  1285.                 gui_unlock_double_buffer();
  1286.                 gui_BLT_double_buffer(x1, y1, x2, y2);
  1288.                 break;
  1289.             }
  1290.         }
  1291.     }
  1292. }
  1295. /*****************************************************************************
  1296.  * FUNCTION
  1297.  *  gui_set_virtual_keyboard_multi_block_mode
  1298.  * DESCRIPTION
  1299.  *  Enter or leave multi-block handwriting mode. 
  1300.  *
  1301.  *  In multi-block handwriting mode, some keyboard icons are displayed differently.
  1302.  * PARAMETERS
  1303.  *  v           [IN/OUT]        
  1304.  *  enabled     [IN]            
  1305.  * RETURNS
  1306.  *  void
  1307.  *****************************************************************************/
  1308. void gui_set_virtual_keyboard_multi_block_mode(virtual_keyboard *v, MMI_BOOL enabled)
  1309. {
  1310.     /*----------------------------------------------------------------*/
  1311.     /* Local Variables                                                */
  1312.     /*----------------------------------------------------------------*/
  1314.     /*----------------------------------------------------------------*/
  1315.     /* Code Body                                                      */
  1316.     /*----------------------------------------------------------------*/
  1317.     if (enabled)
  1318.     {
  1319.         v->flags |= GUI_VKBD_FLAG_MULTI_BLOCK_MODE;
  1320.     }
  1321.     else
  1322.     {
  1323.         v->flags &= ~GUI_VKBD_FLAG_MULTI_BLOCK_MODE;
  1324.     }
  1325. }
  1328. /*****************************************************************************
  1329.  * FUNCTION
  1330.  *  gui_set_virtual_keyboard_allowed_characters
  1331.  * DESCRIPTION
  1332.  *  Only the allowd characters can be input on keyboard.
  1333.  *  This function and gui_set_virtual_board_disable_list() are mutually-exclusive.
  1334.  *  
  1335.  *  Control keys such as GUI_VKBD_PEN_HIDE, GUI_VKBD_PEN_SHOW... are enabled because
  1336.  *  they are not related to character insertion.
  1337.  *  
  1338.  *  `allowed_characters' may contain '-' for consecutive characters
  1339.  *  (Ex. 'a-z' for characters from a to z.)
  1340.  *  If we want to accept "-", please write it as '-'.
  1341.  *  For example, '-0-9.' represents "-0123456789."
  1342.  *  
  1343.  *  Example of valid characters in email addresss:
  1344.  *  wgui_set_virtual_keyboard_allowed_characters((const UI_character_type *) L"+_\-.@A-Za-z0-9");
  1345.  *  (it is not a complete list of all characters allowed in RFC, but it satisfies almost all cases)
  1346.  * PARAMETERS
  1347.  *  v                   [IN/OUT]    Virtual keyboard
  1348.  *  allowed_chars       [IN]        Allowed characters
  1349.  * RETURNS
  1350.  *  void
  1351.  *****************************************************************************/
  1352. void gui_set_virtual_keyboard_allowed_characters(virtual_keyboard *v, const UI_character_type *allowed_chars)
  1353. {
  1354.     /*----------------------------------------------------------------*/
  1355.     /* Local Variables                                                */
  1356.     /*----------------------------------------------------------------*/
  1358.     /*----------------------------------------------------------------*/
  1359.     /* Code Body                                                      */
  1360.     /*----------------------------------------------------------------*/
  1361.     v->allowed_characters = allowed_chars;
  1362. }
  1365. /*****************************************************************************
  1366.  * FUNCTION
  1367.  *  gui_set_virtual_board_disable_list
  1368.  * DESCRIPTION
  1369.  *  Disable some keys on keyboard.
  1370.  *  This function and gui_set_virtual_keyboard_allowed_characters() are mutually-exclusive.
  1371.  * PARAMETERS
  1372.  *  v                       [IN/OUT]    Virtual keyboard
  1373.  *  disabled_chars          [IN]        Null-terminated array of disabled unicode characters
  1374.  *  disabled_symbols        [IN]        Ended by GUI_VKBD_PEN_NONE
  1375.  * RETURNS
  1376.  *  void
  1377.  *****************************************************************************/
  1378. void gui_set_virtual_board_disable_list(
  1379.         virtual_keyboard *v,
  1380.         const UI_character_type *disabled_chars,
  1381.         const gui_virtual_keyboard_pen_enum *disabled_symbols)
  1382. {
  1383.     /*----------------------------------------------------------------*/
  1384.     /* Local Variables                                                */
  1385.     /*----------------------------------------------------------------*/
  1386.     S32 i;
  1388.     /*----------------------------------------------------------------*/
  1389.     /* Code Body                                                      */
  1390.     /*----------------------------------------------------------------*/
  1391.     /* Setup v->disabled_chars[] */
  1392.     for (i = 0; i < MMI_VKBD_MAX_DISABLED_KEYS; i++)
  1393.     {
  1394.         if (!disabled_chars[i])
  1395.         {
  1396.             break;
  1397.         }
  1399.         v->disabled_chars[i] = disabled_chars[i];
  1400.     }
  1402.     MMI_DBG_ASSERT(i < MMI_VKBD_MAX_DISABLED_KEYS || !disabled_chars[i]);
  1403.     v->disabled_chars[i] = 0;
  1405.     /* Setup v->disabled_symbols[] */
  1406.     for (i = 0; i < MMI_VKBD_MAX_DISABLED_KEYS; i++)
  1407.     {
  1408.         if (disabled_symbols[i] == GUI_VKBD_PEN_NONE)
  1409.         {
  1410.             break;
  1411.         }
  1413.         v->disabled_symbols[i] = disabled_symbols[i];
  1414.     }
  1416.     MMI_DBG_ASSERT(i < MMI_VKBD_MAX_DISABLED_KEYS || (disabled_symbols[i] == GUI_VKBD_PEN_NONE));
  1417.     v->disabled_symbols[i] = GUI_VKBD_PEN_NONE;
  1418. }
  1420. #ifdef __MMI_TOUCH_SCREEN__
  1423. /*****************************************************************************
  1424.  * FUNCTION
  1425.  *  gui_virtual_keyboard_translate_pen_event
  1426.  * DESCRIPTION
  1427.  *  
  1428.  * PARAMETERS
  1429.  *  v               [IN/OUT]         
  1430.  *  x               [IN]        
  1431.  *  y               [IN]        
  1432.  *  pen_event       [IN]        
  1433.  *  vkbd_event      [OUT]         
  1434.  *  vkbd_param      [OUT]         
  1435.  * RETURNS
  1436.  *  
  1437.  *****************************************************************************/
  1438. BOOL gui_virtual_keyboard_translate_pen_event(
  1439.         virtual_keyboard *v,
  1440.         S16 x,
  1441.         S16 y,
  1442.         mmi_pen_event_type_enum pen_event,
  1443.         gui_virtual_keyboard_pen_enum *vkbd_event,
  1444.         gui_pen_event_param_struct *vkbd_param)
  1445. {
  1446.     /*----------------------------------------------------------------*/
  1447.     /* Local Variables                                                */
  1448.     /*----------------------------------------------------------------*/
  1449.     BOOL ret = MMI_TRUE;
  1450.     const gui_keyboard_language_struct *lang;
  1451.     UI_character_type ch;
  1452.     gui_virtual_keyboard_pen_enum evt;
  1454.     /*----------------------------------------------------------------*/
  1455.     /* Code Body                                                      */
  1456.     /*----------------------------------------------------------------*/
  1457.     *vkbd_event = GUI_VKBD_PEN_NONE;
  1458.     GUI_PEN_EVENT_PARAM_SET_VOID(vkbd_param);
  1460.     lang = MMI_virtual_keyboard_language_map[v->lang_type].virtual_keyboard_language;
  1462.     switch (pen_event)
  1463.     {
  1464.         case MMI_PEN_EVENT_DOWN:
  1465.             v->key_down_accepted = MMI_FALSE;
  1467.             if (PEN_CHECK_BOUND(x, y, v->x, v->y, v->width, v->height))
  1468.             {
  1469.                 if (gui_virtual_keyboard_translate_pen_position(v, x, y, &v->selected_key))
  1470.                 {
  1471.                     gui_virtual_keyboard_get_selected_key(v, &ch, &evt);
  1472.                     if ((evt == GUI_VKBD_PEN_NONE) || gui_virtual_keyboard_is_key_disabled(v, evt, ch))
  1473.                     {
  1474.                         /* Do nothing */
  1475.                     }
  1476.                     else
  1477.                     {
  1478.                         v->key_down_accepted = MMI_TRUE;
  1480.                         gui_virtual_keyboard_cache_and_show_selected_key(v);
  1481.                         /* 
  1482.                          * If Pen Down and Pen Up comes together, we should temporarily suspend MMI task. 
  1483.                          * Otherwise, user can not see pen down due to delayed LCM update.
  1484.                          */
  1485.                     #ifdef MMI_ON_HARDWARE_P
  1486.                         kal_sleep_task(kal_milli_secs_to_ticks(30));
  1487.                     #endif 
  1488.                     }
  1489.                 }
  1490.             }
  1491.             else
  1492.             {
  1493.                 return MMI_FALSE;
  1494.             }
  1495.             break;
  1497.         case MMI_PEN_EVENT_MOVE:
  1498.             if (v->key_down_accepted)
  1499.             {
  1500.                 virtual_keyboard_selection_struct s;
  1502.                 if (PEN_CHECK_BOUND(x, y, v->x, v->y, v->width, v->height) &&
  1503.                     gui_virtual_keyboard_translate_pen_position(v, x, y, &s))
  1504.                 {
  1505.                     if (memcmp(&v->selected_key, &s, sizeof(s)))
  1506.                     {
  1507.                         gui_virtual_keyboard_show_unselect_key_from_cache(v);
  1508.                         memcpy(&v->selected_key, &s, sizeof(s));
  1509.                         gui_virtual_keyboard_get_selected_key(v, &ch, &evt);
  1510.                         if (!((evt == GUI_VKBD_PEN_NONE) || gui_virtual_keyboard_is_key_disabled(v, evt, ch)))
  1511.                         {
  1512.                             gui_virtual_keyboard_cache_and_show_selected_key(v);
  1513.                         }
  1514.                     }
  1515.                 }
  1516.                 else
  1517.                 {
  1518.                     gui_virtual_keyboard_show_unselect_key_from_cache(v);
  1519.                     gui_virtual_keyboard_clear_selected_key(&v->selected_key);
  1520.                 }
  1521.             }
  1523.             break;
  1525.         case MMI_PEN_EVENT_UP:
  1526.             if (v->key_down_accepted)
  1527.             {
  1528.                 gui_virtual_keyboard_show_unselect_key_from_cache(v);
  1530.                 if (gui_virtual_keyboard_get_selected_key(v, &ch, &evt))
  1531.                 {
  1532.                     gui_virtual_keyboard_translate_dead_key(v, &ch, &evt);
  1534.                     if (evt == GUI_VKBD_PEN_SPACE)
  1535.                     {
  1536.                         evt = GUI_VKBD_PEN_CHAR_I;
  1537.                         ch = (UI_character_type) ' ';
  1538.                     }
  1539.                     else if (evt == GUI_VKBD_PEN_DEAD_KEY)
  1540.                     {
  1541.                         evt = GUI_VKBD_PEN_NONE;
  1542.                     }
  1544.                     *vkbd_event = evt;
  1545.                     if (evt == GUI_VKBD_PEN_CHAR_I)
  1546.                     {
  1547.                         GUI_PEN_EVENT_PARAM_SET_INTEGER(vkbd_param, (int)ch);
  1548.                     }
  1549.                 }
  1550.             }
  1551.             break;
  1553.         case MMI_PEN_EVENT_ABORT:
  1554.             gui_virtual_keyboard_show_unselect_key_from_cache(v);
  1555.             gui_virtual_keyboard_clear_dead_key(v);
  1556.             break;
  1558.         case MMI_PEN_EVENT_LONG_TAP:
  1559.             /* FALLTHROUGH no break */
  1560.         case MMI_PEN_EVENT_REPEAT:
  1561.             /* Do nothing */
  1562.             break;
  1563.     }
  1565.     return ret;
  1566. }
  1568. #endif /* __MMI_TOUCH_SCREEN__ */