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

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

MTK

开发平台：

C/C++

wgui.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.  * Filename:
  38.  * ---------
  39.  *  wgui..c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *  MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *  key_handlers wrappers and initialize UI..
  48.  *
  49.  * Author:
  50.  * -------
  51.  * -------
  52.  *
  53.  *==============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  56.  *------------------------------------------------------------------------------
  57.  * removed!
  58.  * removed!
  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.  * removed!
  93.  *
  94.  * removed!
  95.  * removed!
  96.  * removed!
  97.  * removed!
  98.  * removed!
  99.  */
  101. /**********************************************************************************
  102.    Filename:      wgui.c
  103.    Author:        manju
  104.    Date Created:  August-07-2002
  105.    Contains:      PixTel UI wrapper routines
  106.                Contains several parts and has been split to multiple
  107.                code files. See other files named wgui_*.c and wgui_*.h
  108.                This file contains common functions and data.
  109. **********************************************************************************/
  111. /* Include: MMI header file */
  112. #include "gui_config.h"
  113. #include "gui_themes.h"
  114. #include "wgui.h"
  115. #include "wgui_softkeys.h"
  116. #include "wgui_menu_shortcuts.h"
  117. #include "wgui_fixed_menus.h"
  118. #include "wgui_fixed_menuitems.h"
  119. #include "wgui_status_icons.h"
  120. #include "wgui_inputs.h"
  121. #include "wgui_virtual_keyboard.h"
  122. #include "IdleAppDef.h"
  123. #include "wgui_categories.h"
  124. #include "Gui_Setting.h"
  125. #include "UCS2prot.h"
  126. #include "FunAndGamesDefs.h"
  127. #include "NVRAMType.h"
  128. #include "NVRAMProt.h"
  129. #include "NVRAMEnum.h"
  131. #if(!UI_DISABLE_EMS_INPUT_BOX)
  132. #include "gui_ems.h"
  133. #endif 
  135. /* 
  136.  * removed!
  137.  */
  138. static void (*MMI_keyboard_key_handler) (S32 vkey_code, S32 key_state) = NULL;
  139. static void (*MMI_keyboard_input_handler) (S32 vkey_code) = NULL;
  140. static void (*MMI_keyboard_global_key_handler) (S32 vkey_code, S32 key_state) = NULL;
  141. static void (*MMI_keyboard_global_input_handler) (S32 vkey_code) = NULL;
  142. static void (*MMI_key_input_handler_function) (MMI_key_code_type key_code, MMI_key_event_type key_event);
  143. static void (*MMI_key_down_handler_function) (MMI_key_code_type key_code);
  144. static void (*MMI_key_up_handler_function) (MMI_key_code_type key_code);
  146. /* 
  147.  * removed!
  148.  */
  149. U8 MMI_disable_title_shortcut_display = 0;
  150. S32 MMI_status_bar_height;
  151. S32 MMI_content_x;
  152. S32 MMI_content_y;
  153. S32 MMI_content_width;
  154. S32 MMI_content_height;
  156. extern MMI_theme theme_Default;
  157. extern MMI_theme **MMI_themes;
  159. /* 
  160.  * removed!
  161.  */
  164. /*****************************************************************************
  165.  * removed!
  166.  * removed!
  167.  * removed!
  168.  * removed!
  169.  * removed!
  170.  * removed!
  171.  * removed!
  172.  * removed!
  173.  *****************************************************************************/
  174. void MMI_dummy_function(void)
  175. {
  176.     /*----------------------------------------------------------------*/
  177.     /* Local Variables                                                */
  178.     /*----------------------------------------------------------------*/
  180.     /*----------------------------------------------------------------*/
  181.     /* Code Body                                                      */
  182.     /*----------------------------------------------------------------*/
  183. }
  185. /* Functions for keyboard Support   */
  188. /*****************************************************************************
  189.  * FUNCTION
  190.  *  dummy_keyboard_key_handler
  191.  * DESCRIPTION
  192.  *  Dummy keyboard key handler
  193.  * PARAMETERS
  194.  *  vkey_code       [IN]        Key_code
  195.  *  key_state       [IN]        Key_state
  196.  * RETURNS
  197.  *  void
  198.  *****************************************************************************/
  199. void dummy_keyboard_key_handler(S32 vkey_code, S32 key_state)
  200. {
  201.     /*----------------------------------------------------------------*/
  202.     /* Local Variables                                                */
  203.     /*----------------------------------------------------------------*/
  205.     /*----------------------------------------------------------------*/
  206.     /* Code Body                                                      */
  207.     /*----------------------------------------------------------------*/
  208.     UI_UNUSED_PARAMETER(vkey_code);
  209.     UI_UNUSED_PARAMETER(key_state);
  210. }
  213. /*****************************************************************************
  214.  * FUNCTION
  215.  *  dummy_keyboard_input_handler
  216.  * DESCRIPTION
  217.  *  Dummy keyboard input handler
  218.  * PARAMETERS
  219.  *  vkey_code       [IN]        Key_code
  220.  * RETURNS
  221.  *  void
  222.  *****************************************************************************/
  223. void dummy_keyboard_input_handler(S32 vkey_code)
  224. {
  225.     /*----------------------------------------------------------------*/
  226.     /* Local Variables                                                */
  227.     /*----------------------------------------------------------------*/
  229.     /*----------------------------------------------------------------*/
  230.     /* Code Body                                                      */
  231.     /*----------------------------------------------------------------*/
  232.     UI_UNUSED_PARAMETER(vkey_code);
  233. }
  236. /*****************************************************************************
  237.  * FUNCTION
  238.  *  keyboard_key_handler
  239.  * DESCRIPTION
  240.  *  Handles key events (UP/DOWN)
  241.  * PARAMETERS
  242.  *  vkey_code       [IN]        Key's scan code
  243.  *  key_state       [IN]        Key's state (up or down)
  244.  * RETURNS
  245.  *  void
  246.  *****************************************************************************/
  247. void keyboard_key_handler(S32 vkey_code, S32 key_state)
  248. {
  249.     /*----------------------------------------------------------------*/
  250.     /* Local Variables                                                */
  251.     /*----------------------------------------------------------------*/
  252.     U8 state = 0;
  254.     /*----------------------------------------------------------------*/
  255.     /* Code Body                                                      */
  256.     /*----------------------------------------------------------------*/
  257.     /* Perform scan code and key state mapping here */
  258.     if (key_state == KEYBOARD_KEY_DOWN)
  259.     {
  260.         state = 1;
  261.     }
  262.     else if (key_state == KEYBOARD_KEY_UP)
  263.     {
  264.         state = 0;
  265.     }
  266.     if (MMI_keyboard_key_handler != NULL)
  267.     {
  268.         MMI_keyboard_key_handler(vkey_code, state);
  269.     }
  270. }
  273. /*****************************************************************************
  274.  * FUNCTION
  275.  *  keyboard_input_handler
  276.  * DESCRIPTION
  277.  *  Handles keyboard input
  278.  * PARAMETERS
  279.  *  vkey_code       [IN]        Key's character code (ASCII)
  280.  * RETURNS
  281.  *  void
  282.  *****************************************************************************/
  283. void keyboard_input_handler(S32 vkey_code)
  284. {
  285.     /*----------------------------------------------------------------*/
  286.     /* Local Variables                                                */
  287.     /*----------------------------------------------------------------*/
  289.     /*----------------------------------------------------------------*/
  290.     /* Code Body                                                      */
  291.     /*----------------------------------------------------------------*/
  292.     if (MMI_keyboard_input_handler != NULL)
  293.     {
  294.         MMI_keyboard_input_handler(vkey_code);
  295.     }
  296. }
  299. /*****************************************************************************
  300.  * FUNCTION
  301.  *  keyboard_global_key_handler
  302.  * DESCRIPTION
  303.  *  Handles key events (UP/DOWN)
  304.  * PARAMETERS
  305.  *  vkey_code       [IN]        Key's scan code
  306.  *  key_state       [IN]        Key's state (up or down)
  307.  * RETURNS
  308.  *  void
  309.  *****************************************************************************/
  310. void keyboard_global_key_handler(S32 vkey_code, S32 key_state)
  311. {
  312.     /*----------------------------------------------------------------*/
  313.     /* Local Variables                                                */
  314.     /*----------------------------------------------------------------*/
  315.     U8 state = 0;
  317.     /*----------------------------------------------------------------*/
  318.     /* Code Body                                                      */
  319.     /*----------------------------------------------------------------*/
  320.     /* Perform scan code and key state mapping here */
  321.     if (key_state == KEYBOARD_KEY_DOWN)
  322.     {
  323.         state = 1;
  324.     }
  325.     else if (key_state == KEYBOARD_KEY_UP)
  326.     {
  327.         state = 0;
  328.     }
  330.     if (MMI_keyboard_global_key_handler != NULL)
  331.     {
  332.         MMI_keyboard_global_key_handler(vkey_code, state);
  333.     }
  334. }
  337. /*****************************************************************************
  338.  * FUNCTION
  339.  *  keyboard_global_input_handler
  340.  * DESCRIPTION
  341.  *  Handles keyboard input
  342.  * PARAMETERS
  343.  *  vkey_code       [IN]        Key's character code (ASCII)
  344.  * RETURNS
  345.  *  void
  346.  *****************************************************************************/
  347. void keyboard_global_input_handler(S32 vkey_code)
  348. {
  349.     /*----------------------------------------------------------------*/
  350.     /* Local Variables                                                */
  351.     /*----------------------------------------------------------------*/
  353.     /*----------------------------------------------------------------*/
  354.     /* Code Body                                                      */
  355.     /*----------------------------------------------------------------*/
  356.     if (MMI_keyboard_global_input_handler != NULL)
  357.     {
  358.         MMI_keyboard_global_input_handler(vkey_code);
  359.     }
  360. }
  363. /*****************************************************************************
  364.  * FUNCTION
  365.  *  register_keyboard_key_handler
  366.  * DESCRIPTION
  367.  *  Registers a function to be called for key handling
  368.  * PARAMETERS
  369.  *  f       [IN]        Function to be called for key handling
  370.  * RETURNS
  371.  *  void
  372.  *****************************************************************************/
  373. void register_keyboard_key_handler(void (*f) (S32 vkey_code, S32 key_state))
  374. {
  375.     /*----------------------------------------------------------------*/
  376.     /* Local Variables                                                */
  377.     /*----------------------------------------------------------------*/
  379.     /*----------------------------------------------------------------*/
  380.     /* Code Body                                                      */
  381.     /*----------------------------------------------------------------*/
  382.     MMI_keyboard_key_handler = f;
  383. }
  386. /*****************************************************************************
  387.  * FUNCTION
  388.  *  register_keyboard_input_handler
  389.  * DESCRIPTION
  390.  *  Registers a function to be called for key input
  391.  * PARAMETERS
  392.  *  f       [IN]        Function that is called upon key events
  393.  * RETURNS
  394.  *  void
  395.  *****************************************************************************/
  396. void register_keyboard_input_handler(void (*f) (S32 vkey_code))
  397. {
  398.     /*----------------------------------------------------------------*/
  399.     /* Local Variables                                                */
  400.     /*----------------------------------------------------------------*/
  402.     /*----------------------------------------------------------------*/
  403.     /* Code Body                                                      */
  404.     /*----------------------------------------------------------------*/
  405.     MMI_keyboard_input_handler = f;
  406. }
  409. /*****************************************************************************
  410.  * FUNCTION
  411.  *  register_keyboard_global_key_handler
  412.  * DESCRIPTION
  413.  *  Registers a function to be called for key handling
  414.  * PARAMETERS
  415.  *  f       [IN]        Function that is called upon key events
  416.  * RETURNS
  417.  *  void
  418.  *****************************************************************************/
  419. void register_keyboard_global_key_handler(void (*f) (S32 vkey_code, S32 key_state))
  420. {
  421.     /*----------------------------------------------------------------*/
  422.     /* Local Variables                                                */
  423.     /*----------------------------------------------------------------*/
  425.     /*----------------------------------------------------------------*/
  426.     /* Code Body                                                      */
  427.     /*----------------------------------------------------------------*/
  428.     MMI_keyboard_global_key_handler = f;
  429. }
  432. /*****************************************************************************
  433.  * FUNCTION
  434.  *  register_keyboard_global_input_handler
  435.  * DESCRIPTION
  436.  *  Register_keyboard_global_input_handler
  437.  * PARAMETERS
  438.  *  f       [IN]        Function that is called upon key events
  439.  * RETURNS
  440.  *  void
  441.  *****************************************************************************/
  442. void register_keyboard_global_input_handler(void (*f) (S32 vkey_code))
  443. {
  444.     /*----------------------------------------------------------------*/
  445.     /* Local Variables                                                */
  446.     /*----------------------------------------------------------------*/
  448.     /*----------------------------------------------------------------*/
  449.     /* Code Body                                                      */
  450.     /*----------------------------------------------------------------*/
  451.     MMI_keyboard_global_input_handler = f;
  452. }
  455. /*****************************************************************************
  456.  * FUNCTION
  457.  *  clear_keyboard_key_handler
  458.  * DESCRIPTION
  459.  *  Clears the function called to handle key events
  460.  * PARAMETERS
  461.  *  void
  462.  * RETURNS
  463.  *  void
  464.  *****************************************************************************/
  465. void clear_keyboard_key_handler(void)
  466. {
  467.     /*----------------------------------------------------------------*/
  468.     /* Local Variables                                                */
  469.     /*----------------------------------------------------------------*/
  471.     /*----------------------------------------------------------------*/
  472.     /* Code Body                                                      */
  473.     /*----------------------------------------------------------------*/
  474.     MMI_keyboard_key_handler = dummy_keyboard_key_handler;
  475. }
  478. /*****************************************************************************
  479.  * FUNCTION
  480.  *  clear_keyboard_input_handler
  481.  * DESCRIPTION
  482.  *  Clears the function called to handle key input
  483.  * PARAMETERS
  484.  *  void
  485.  * RETURNS
  486.  *  void
  487.  *****************************************************************************/
  488. void clear_keyboard_input_handler(void)
  489. {
  490.     /*----------------------------------------------------------------*/
  491.     /* Local Variables                                                */
  492.     /*----------------------------------------------------------------*/
  494.     /*----------------------------------------------------------------*/
  495.     /* Code Body                                                      */
  496.     /*----------------------------------------------------------------*/
  497.     MMI_keyboard_input_handler = dummy_keyboard_input_handler;
  498. }
  501. /*****************************************************************************
  502.  * FUNCTION
  503.  *  clear_keyboard_global_key_handler
  504.  * DESCRIPTION
  505.  *  Clears the function called to handle key events
  506.  * PARAMETERS
  507.  *  void
  508.  * RETURNS
  509.  *  void
  510.  *****************************************************************************/
  511. void clear_keyboard_global_key_handler(void)
  512. {
  513.     /*----------------------------------------------------------------*/
  514.     /* Local Variables                                                */
  515.     /*----------------------------------------------------------------*/
  517.     /*----------------------------------------------------------------*/
  518.     /* Code Body                                                      */
  519.     /*----------------------------------------------------------------*/
  520.     MMI_keyboard_global_key_handler = dummy_keyboard_key_handler;
  521. }
  524. /*****************************************************************************
  525.  * FUNCTION
  526.  *  clear_keyboard_global_input_handler
  527.  * DESCRIPTION
  528.  *  Clears the function called to handle key input
  529.  * PARAMETERS
  530.  *  void
  531.  * RETURNS
  532.  *  void
  533.  *****************************************************************************/
  534. void clear_keyboard_global_input_handler(void)
  535. {
  536.     /*----------------------------------------------------------------*/
  537.     /* Local Variables                                                */
  538.     /*----------------------------------------------------------------*/
  540.     /*----------------------------------------------------------------*/
  541.     /* Code Body                                                      */
  542.     /*----------------------------------------------------------------*/
  543.     MMI_keyboard_global_input_handler = dummy_keyboard_input_handler;
  544. }
  546. /* Key handling wrappers      */
  549. /*****************************************************************************
  550.  * FUNCTION
  551.  *  clear_key_handlers
  552.  * DESCRIPTION
  553.  *  Clears the key handlers
  554.  * PARAMETERS
  555.  *  void
  556.  * RETURNS
  557.  *  void
  558.  *****************************************************************************/
  559. void clear_key_handlers(void)
  560. {
  561.     /*----------------------------------------------------------------*/
  562.     /* Local Variables                                                */
  563.     /*----------------------------------------------------------------*/
  565.     /*----------------------------------------------------------------*/
  566.     /* Code Body                                                      */
  567.     /*----------------------------------------------------------------*/
  568.     clear_softkey_handler(KEY_LSK);
  569.     clear_softkey_handler(KEY_RSK);
  570. #ifdef __MMI_WGUI_CSK_ENABLE__
  571.     clear_softkey_handler(KEY_CSK);
  572. #endif 
  573.     register_keyboard_key_handler(dummy_keyboard_key_handler);
  574.     register_keyboard_input_handler(dummy_keyboard_input_handler);
  575.     register_keyboard_global_input_handler(dummy_keyboard_input_handler);
  576.     ClearInputEventHandler(MMI_DEVICE_KEY);
  577. }
  580. /*****************************************************************************
  581.  * FUNCTION
  582.  *  clear_category_screen_key_handlers
  583.  * DESCRIPTION
  584.  *  Clears the key handlers used in category screen
  585.  * PARAMETERS
  586.  *  void
  587.  * RETURNS
  588.  *  void
  589.  *****************************************************************************/
  590. void clear_category_screen_key_handlers(void)
  591. {
  592.     /*----------------------------------------------------------------*/
  593.     /* Local Variables                                                */
  594.     /*----------------------------------------------------------------*/
  596.     /*----------------------------------------------------------------*/
  597.     /* Code Body                                                      */
  598.     /*----------------------------------------------------------------*/
  599.     clear_softkey_handler(KEY_LSK);
  600.     clear_softkey_handler(KEY_RSK);
  601. #ifdef __MMI_WGUI_CSK_ENABLE__
  602.     clear_softkey_handler(KEY_CSK);
  603. #endif 
  604.     register_keyboard_key_handler(dummy_keyboard_key_handler);
  605.     register_keyboard_input_handler(dummy_keyboard_input_handler);
  606. }
  609. /*****************************************************************************
  610.  * FUNCTION
  611.  *  register_key_input_handler
  612.  * DESCRIPTION
  613.  *  Registers a key input handler for a keypad key
  614.  * PARAMETERS
  615.  *  f       [IN]        Function that is called on receiving key events
  616.  * RETURNS
  617.  *  void
  618.  *****************************************************************************/
  619. void register_key_input_handler(void (*f) (MMI_key_code_type key_code, MMI_key_event_type key_event))
  620. {
  621.     /*----------------------------------------------------------------*/
  622.     /* Local Variables                                                */
  623.     /*----------------------------------------------------------------*/
  625.     /*----------------------------------------------------------------*/
  626.     /* Code Body                                                      */
  627.     /*----------------------------------------------------------------*/
  628.     MMI_key_input_handler_function = f;
  629. }
  632. /*****************************************************************************
  633.  * FUNCTION
  634.  *  register_key_up_handler
  635.  * DESCRIPTION
  636.  *  Registers handler for the key up events of all keys
  637.  * PARAMETERS
  638.  *  f       [IN]        Function that is called whenever any key is released
  639.  * RETURNS
  640.  *  void
  641.  *****************************************************************************/
  642. void register_key_up_handler(void (*f) (MMI_key_code_type key_code))
  643. {
  644.     /*----------------------------------------------------------------*/
  645.     /* Local Variables                                                */
  646.     /*----------------------------------------------------------------*/
  648.     /*----------------------------------------------------------------*/
  649.     /* Code Body                                                      */
  650.     /*----------------------------------------------------------------*/
  651.     MMI_key_up_handler_function = f;
  652. }
  655. /*****************************************************************************
  656.  * FUNCTION
  657.  *  register_key_down_handler
  658.  * DESCRIPTION
  659.  *  Registers handler for the key down events of all keys
  660.  * PARAMETERS
  661.  *  f       [IN]        Function that is called whenever any key is pressed
  662.  * RETURNS
  663.  *  void
  664.  *****************************************************************************/
  665. void register_key_down_handler(void (*f) (MMI_key_code_type key_code))
  666. {
  667.     /*----------------------------------------------------------------*/
  668.     /* Local Variables                                                */
  669.     /*----------------------------------------------------------------*/
  671.     /*----------------------------------------------------------------*/
  672.     /* Code Body                                                      */
  673.     /*----------------------------------------------------------------*/
  674.     MMI_key_down_handler_function = f;
  675. }
  678. /*****************************************************************************
  679.  * FUNCTION
  680.  *  clear_key_input_handler
  681.  * DESCRIPTION
  682.  *  Clears the key input handler
  683.  * PARAMETERS
  684.  *  void
  685.  * RETURNS
  686.  *  void
  687.  *****************************************************************************/
  688. void clear_key_input_handler(void)
  689. {
  690.     /*----------------------------------------------------------------*/
  691.     /* Local Variables                                                */
  692.     /*----------------------------------------------------------------*/
  694.     /*----------------------------------------------------------------*/
  695.     /* Code Body                                                      */
  696.     /*----------------------------------------------------------------*/
  697.     MMI_key_input_handler_function = NULL;
  698. }
  701. /*****************************************************************************
  702.  * FUNCTION
  703.  *  clear_key_down_handler
  704.  * DESCRIPTION
  705.  *  Clears the key down handler
  706.  * PARAMETERS
  707.  *  void
  708.  * RETURNS
  709.  *  void
  710.  *****************************************************************************/
  711. void clear_key_down_handler(void)
  712. {
  713.     /*----------------------------------------------------------------*/
  714.     /* Local Variables                                                */
  715.     /*----------------------------------------------------------------*/
  717.     /*----------------------------------------------------------------*/
  718.     /* Code Body                                                      */
  719.     /*----------------------------------------------------------------*/
  720.     MMI_key_down_handler_function = NULL;
  721. }
  724. /*****************************************************************************
  725.  * FUNCTION
  726.  *  clear_key_up_handler
  727.  * DESCRIPTION
  728.  *  Clears the key up handler
  729.  * PARAMETERS
  730.  *  void
  731.  * RETURNS
  732.  *  void
  733.  *****************************************************************************/
  734. void clear_key_up_handler(void)
  735. {
  736.     /*----------------------------------------------------------------*/
  737.     /* Local Variables                                                */
  738.     /*----------------------------------------------------------------*/
  740.     /*----------------------------------------------------------------*/
  741.     /* Code Body                                                      */
  742.     /*----------------------------------------------------------------*/
  743.     MMI_key_up_handler_function = NULL;
  744. }
  746. /*----------------------------------------------------------------------------
  747.    The following functions are used internally and are not meant to be called
  748.    by other functions.
  749. ----------------------------------------------------------------------------*/
  752. /*****************************************************************************
  753.  * FUNCTION
  754.  *  MMI_key_input_handler
  755.  * DESCRIPTION
  756.  *  Handler key input events
  757.  * PARAMETERS
  758.  *  key_code        [IN]        
  759.  *  key_event       [IN]        
  760.  * RETURNS
  761.  *  void
  762.  *****************************************************************************/
  763. void MMI_key_input_handler(MMI_key_code_type key_code, MMI_key_event_type key_event)
  764. {
  765.     /*----------------------------------------------------------------*/
  766.     /* Local Variables                                                */
  767.     /*----------------------------------------------------------------*/
  769.     /*----------------------------------------------------------------*/
  770.     /* Code Body                                                      */
  771.     /*----------------------------------------------------------------*/
  772.     if (MMI_key_input_handler_function != NULL)
  773.     {
  774.         MMI_key_input_handler_function(key_code, key_event);
  775.     }
  777.     switch (key_event)
  778.     {
  779.         case KEY_EVENT_DOWN:
  780.             if (MMI_key_down_handler_function != NULL)
  781.             {
  782.                 MMI_key_down_handler_function(key_code);
  783.             }
  784.             break;
  785.         case KEY_EVENT_UP:
  786.             if (MMI_key_up_handler_function != NULL)
  787.             {
  788.                 MMI_key_up_handler_function(key_code);
  789.             }
  790.             break;
  791.     }
  792. }
  795. /*****************************************************************************
  796.  * FUNCTION
  797.  *  MMI_key_0_down
  798.  * DESCRIPTION
  799.  *  Handle key 0 pressed event
  800.  * PARAMETERS
  801.  *  void
  802.  * RETURNS
  803.  *  void
  804.  *****************************************************************************/
  805. void MMI_key_0_down(void)
  806. {
  807.     /*----------------------------------------------------------------*/
  808.     /* Local Variables                                                */
  809.     /*----------------------------------------------------------------*/
  811.     /*----------------------------------------------------------------*/
  812.     /* Code Body                                                      */
  813.     /*----------------------------------------------------------------*/
  814.     MMI_key_input_handler(KEY_0, KEY_EVENT_DOWN);
  815. }
  818. /*****************************************************************************
  819.  * FUNCTION
  820.  *  MMI_key_1_down
  821.  * DESCRIPTION
  822.  *  Handle key 1 pressed event
  823.  * PARAMETERS
  824.  *  void
  825.  * RETURNS
  826.  *  void
  827.  *****************************************************************************/
  828. void MMI_key_1_down(void)
  829. {
  830.     /*----------------------------------------------------------------*/
  831.     /* Local Variables                                                */
  832.     /*----------------------------------------------------------------*/
  834.     /*----------------------------------------------------------------*/
  835.     /* Code Body                                                      */
  836.     /*----------------------------------------------------------------*/
  837.     MMI_key_input_handler(KEY_1, KEY_EVENT_DOWN);
  838. }
  841. /*****************************************************************************
  842.  * FUNCTION
  843.  *  MMI_key_2_down
  844.  * DESCRIPTION
  845.  *  Handle key 2 pressed event
  846.  * PARAMETERS
  847.  *  void
  848.  * RETURNS
  849.  *  void
  850.  *****************************************************************************/
  851. void MMI_key_2_down(void)
  852. {
  853.     /*----------------------------------------------------------------*/
  854.     /* Local Variables                                                */
  855.     /*----------------------------------------------------------------*/
  857.     /*----------------------------------------------------------------*/
  858.     /* Code Body                                                      */
  859.     /*----------------------------------------------------------------*/
  860.     MMI_key_input_handler(KEY_2, KEY_EVENT_DOWN);
  861. }
  864. /*****************************************************************************
  865.  * FUNCTION
  866.  *  MMI_key_3_down
  867.  * DESCRIPTION
  868.  *  Handle key 3 pressed event
  869.  * PARAMETERS
  870.  *  void
  871.  * RETURNS
  872.  *  void
  873.  *****************************************************************************/
  874. void MMI_key_3_down(void)
  875. {
  876.     /*----------------------------------------------------------------*/
  877.     /* Local Variables                                                */
  878.     /*----------------------------------------------------------------*/
  880.     /*----------------------------------------------------------------*/
  881.     /* Code Body                                                      */
  882.     /*----------------------------------------------------------------*/
  883.     MMI_key_input_handler(KEY_3, KEY_EVENT_DOWN);
  884. }
  887. /*****************************************************************************
  888.  * FUNCTION
  889.  *  MMI_key_4_down
  890.  * DESCRIPTION
  891.  *  Handle key 4 pressed event
  892.  * PARAMETERS
  893.  *  void
  894.  * RETURNS
  895.  *  void
  896.  *****************************************************************************/
  897. void MMI_key_4_down(void)
  898. {
  899.     /*----------------------------------------------------------------*/
  900.     /* Local Variables                                                */
  901.     /*----------------------------------------------------------------*/
  903.     /*----------------------------------------------------------------*/
  904.     /* Code Body                                                      */
  905.     /*----------------------------------------------------------------*/
  906.     MMI_key_input_handler(KEY_4, KEY_EVENT_DOWN);
  907. }
  910. /*****************************************************************************
  911.  * FUNCTION
  912.  *  MMI_key_5_down
  913.  * DESCRIPTION
  914.  *  Handle key 5 pressed event
  915.  * PARAMETERS
  916.  *  void
  917.  * RETURNS
  918.  *  void
  919.  *****************************************************************************/
  920. void MMI_key_5_down(void)
  921. {
  922.     /*----------------------------------------------------------------*/
  923.     /* Local Variables                                                */
  924.     /*----------------------------------------------------------------*/
  926.     /*----------------------------------------------------------------*/
  927.     /* Code Body                                                      */
  928.     /*----------------------------------------------------------------*/
  929.     MMI_key_input_handler(KEY_5, KEY_EVENT_DOWN);
  930. }
  933. /*****************************************************************************
  934.  * FUNCTION
  935.  *  MMI_key_6_down
  936.  * DESCRIPTION
  937.  *  Handle key 6 pressed event
  938.  * PARAMETERS
  939.  *  void
  940.  * RETURNS
  941.  *  void
  942.  *****************************************************************************/
  943. void MMI_key_6_down(void)
  944. {
  945.     /*----------------------------------------------------------------*/
  946.     /* Local Variables                                                */
  947.     /*----------------------------------------------------------------*/
  949.     /*----------------------------------------------------------------*/
  950.     /* Code Body                                                      */
  951.     /*----------------------------------------------------------------*/
  952.     MMI_key_input_handler(KEY_6, KEY_EVENT_DOWN);
  953. }
  956. /*****************************************************************************
  957.  * FUNCTION
  958.  *  MMI_key_7_down
  959.  * DESCRIPTION
  960.  *  Handle key 7 pressed event
  961.  * PARAMETERS
  962.  *  void
  963.  * RETURNS
  964.  *  void
  965.  *****************************************************************************/
  966. void MMI_key_7_down(void)
  967. {
  968.     /*----------------------------------------------------------------*/
  969.     /* Local Variables                                                */
  970.     /*----------------------------------------------------------------*/
  972.     /*----------------------------------------------------------------*/
  973.     /* Code Body                                                      */
  974.     /*----------------------------------------------------------------*/
  975.     MMI_key_input_handler(KEY_7, KEY_EVENT_DOWN);
  976. }
  979. /*****************************************************************************
  980.  * FUNCTION
  981.  *  MMI_key_8_down
  982.  * DESCRIPTION
  983.  *  Handle key 8 pressed event
  984.  * PARAMETERS
  985.  *  void
  986.  * RETURNS
  987.  *  void
  988.  *****************************************************************************/
  989. void MMI_key_8_down(void)
  990. {
  991.     /*----------------------------------------------------------------*/
  992.     /* Local Variables                                                */
  993.     /*----------------------------------------------------------------*/
  995.     /*----------------------------------------------------------------*/
  996.     /* Code Body                                                      */
  997.     /*----------------------------------------------------------------*/
  998.     MMI_key_input_handler(KEY_8, KEY_EVENT_DOWN);
  999. }
  1002. /*****************************************************************************
  1003.  * FUNCTION
  1004.  *  MMI_key_9_down
  1005.  * DESCRIPTION
  1006.  *  Handle key 9 pressed event
  1007.  * PARAMETERS
  1008.  *  void
  1009.  * RETURNS
  1010.  *  void
  1011.  *****************************************************************************/
  1012. void MMI_key_9_down(void)
  1013. {
  1014.     /*----------------------------------------------------------------*/
  1015.     /* Local Variables                                                */
  1016.     /*----------------------------------------------------------------*/
  1018.     /*----------------------------------------------------------------*/
  1019.     /* Code Body                                                      */
  1020.     /*----------------------------------------------------------------*/
  1021.     MMI_key_input_handler(KEY_9, KEY_EVENT_DOWN);
  1022. }
  1024. /* multitap for star and Pound */
  1027. /*****************************************************************************
  1028.  * FUNCTION
  1029.  *  MMI_key_star_down
  1030.  * DESCRIPTION
  1031.  *  Handle key star pressed event
  1032.  * PARAMETERS
  1033.  *  void
  1034.  * RETURNS
  1035.  *  void
  1036.  *****************************************************************************/
  1037. void MMI_key_star_down(void)
  1038. {
  1039.     /*----------------------------------------------------------------*/
  1040.     /* Local Variables                                                */
  1041.     /*----------------------------------------------------------------*/
  1043.     /*----------------------------------------------------------------*/
  1044.     /* Code Body                                                      */
  1045.     /*----------------------------------------------------------------*/
  1046.     MMI_key_input_handler(KEY_STAR, KEY_EVENT_DOWN);
  1047. }
  1050. /*****************************************************************************
  1051.  * FUNCTION
  1052.  *  MMI_key_pound_down
  1053.  * DESCRIPTION
  1054.  *  Handle key pound pressed event
  1055.  * PARAMETERS
  1056.  *  void
  1057.  * RETURNS
  1058.  *  void
  1059.  *****************************************************************************/
  1060. void MMI_key_pound_down(void)
  1061. {
  1062.     /*----------------------------------------------------------------*/
  1063.     /* Local Variables                                                */
  1064.     /*----------------------------------------------------------------*/
  1066.     /*----------------------------------------------------------------*/
  1067.     /* Code Body                                                      */
  1068.     /*----------------------------------------------------------------*/
  1069.     MMI_key_input_handler(KEY_POUND, KEY_EVENT_DOWN);
  1070. }
  1073. /*****************************************************************************
  1074.  * FUNCTION
  1075.  *  MMI_key_0_up
  1076.  * DESCRIPTION
  1077.  *  Handle key 0 release event
  1078.  * PARAMETERS
  1079.  *  void
  1080.  * RETURNS
  1081.  *  void
  1082.  *****************************************************************************/
  1083. void MMI_key_0_up(void)
  1084. {
  1085.     /*----------------------------------------------------------------*/
  1086.     /* Local Variables                                                */
  1087.     /*----------------------------------------------------------------*/
  1089.     /*----------------------------------------------------------------*/
  1090.     /* Code Body                                                      */
  1091.     /*----------------------------------------------------------------*/
  1092.     MMI_key_input_handler(KEY_0, KEY_EVENT_UP);
  1093. }
  1096. /*****************************************************************************
  1097.  * FUNCTION
  1098.  *  MMI_key_1_up
  1099.  * DESCRIPTION
  1100.  *  Handle key 1 release event
  1101.  * PARAMETERS
  1102.  *  void
  1103.  * RETURNS
  1104.  *  void
  1105.  *****************************************************************************/
  1106. void MMI_key_1_up(void)
  1107. {
  1108.     /*----------------------------------------------------------------*/
  1109.     /* Local Variables                                                */
  1110.     /*----------------------------------------------------------------*/
  1112.     /*----------------------------------------------------------------*/
  1113.     /* Code Body                                                      */
  1114.     /*----------------------------------------------------------------*/
  1115.     MMI_key_input_handler(KEY_1, KEY_EVENT_UP);
  1116. }
  1119. /*****************************************************************************
  1120.  * FUNCTION
  1121.  *  MMI_key_2_up
  1122.  * DESCRIPTION
  1123.  *  Handle key 2 release event
  1124.  * PARAMETERS
  1125.  *  void
  1126.  * RETURNS
  1127.  *  void
  1128.  *****************************************************************************/
  1129. void MMI_key_2_up(void)
  1130. {
  1131.     /*----------------------------------------------------------------*/
  1132.     /* Local Variables                                                */
  1133.     /*----------------------------------------------------------------*/
  1135.     /*----------------------------------------------------------------*/
  1136.     /* Code Body                                                      */
  1137.     /*----------------------------------------------------------------*/
  1138.     MMI_key_input_handler(KEY_2, KEY_EVENT_UP);
  1139. }
  1142. /*****************************************************************************
  1143.  * FUNCTION
  1144.  *  MMI_key_3_up
  1145.  * DESCRIPTION
  1146.  *  Handle key 3 release event
  1147.  * PARAMETERS
  1148.  *  void
  1149.  * RETURNS
  1150.  *  void
  1151.  *****************************************************************************/
  1152. void MMI_key_3_up(void)
  1153. {
  1154.     /*----------------------------------------------------------------*/
  1155.     /* Local Variables                                                */
  1156.     /*----------------------------------------------------------------*/
  1158.     /*----------------------------------------------------------------*/
  1159.     /* Code Body                                                      */
  1160.     /*----------------------------------------------------------------*/
  1161.     MMI_key_input_handler(KEY_3, KEY_EVENT_UP);
  1162. }
  1165. /*****************************************************************************
  1166.  * FUNCTION
  1167.  *  MMI_key_4_up
  1168.  * DESCRIPTION
  1169.  *  Handle key 4 release event
  1170.  * PARAMETERS
  1171.  *  void
  1172.  * RETURNS
  1173.  *  void
  1174.  *****************************************************************************/
  1175. void MMI_key_4_up(void)
  1176. {
  1177.     /*----------------------------------------------------------------*/
  1178.     /* Local Variables                                                */
  1179.     /*----------------------------------------------------------------*/
  1181.     /*----------------------------------------------------------------*/
  1182.     /* Code Body                                                      */
  1183.     /*----------------------------------------------------------------*/
  1184.     MMI_key_input_handler(KEY_4, KEY_EVENT_UP);
  1185. }
  1188. /*****************************************************************************
  1189.  * FUNCTION
  1190.  *  MMI_key_5_up
  1191.  * DESCRIPTION
  1192.  *  Handle key 5 release event
  1193.  * PARAMETERS
  1194.  *  void
  1195.  * RETURNS
  1196.  *  void
  1197.  *****************************************************************************/
  1198. void MMI_key_5_up(void)
  1199. {
  1200.     /*----------------------------------------------------------------*/
  1201.     /* Local Variables                                                */
  1202.     /*----------------------------------------------------------------*/
  1204.     /*----------------------------------------------------------------*/
  1205.     /* Code Body                                                      */
  1206.     /*----------------------------------------------------------------*/
  1207.     MMI_key_input_handler(KEY_5, KEY_EVENT_UP);
  1208. }
  1211. /*****************************************************************************
  1212.  * FUNCTION
  1213.  *  MMI_key_6_up
  1214.  * DESCRIPTION
  1215.  *  Handle key 6 release event
  1216.  * PARAMETERS
  1217.  *  void
  1218.  * RETURNS
  1219.  *  void
  1220.  *****************************************************************************/
  1221. void MMI_key_6_up(void)
  1222. {
  1223.     /*----------------------------------------------------------------*/
  1224.     /* Local Variables                                                */
  1225.     /*----------------------------------------------------------------*/
  1227.     /*----------------------------------------------------------------*/
  1228.     /* Code Body                                                      */
  1229.     /*----------------------------------------------------------------*/
  1230.     MMI_key_input_handler(KEY_6, KEY_EVENT_UP);
  1231. }
  1234. /*****************************************************************************
  1235.  * FUNCTION
  1236.  *  MMI_key_7_up
  1237.  * DESCRIPTION
  1238.  *  Handle key 7 release event
  1239.  * PARAMETERS
  1240.  *  void
  1241.  * RETURNS
  1242.  *  void
  1243.  *****************************************************************************/
  1244. void MMI_key_7_up(void)
  1245. {
  1246.     /*----------------------------------------------------------------*/
  1247.     /* Local Variables                                                */
  1248.     /*----------------------------------------------------------------*/
  1250.     /*----------------------------------------------------------------*/
  1251.     /* Code Body                                                      */
  1252.     /*----------------------------------------------------------------*/
  1253.     MMI_key_input_handler(KEY_7, KEY_EVENT_UP);
  1254. }
  1257. /*****************************************************************************
  1258.  * FUNCTION
  1259.  *  MMI_key_8_up
  1260.  * DESCRIPTION
  1261.  *  Handle key 8 release event
  1262.  * PARAMETERS
  1263.  *  void
  1264.  * RETURNS
  1265.  *  void
  1266.  *****************************************************************************/
  1267. void MMI_key_8_up(void)
  1268. {
  1269.     /*----------------------------------------------------------------*/
  1270.     /* Local Variables                                                */
  1271.     /*----------------------------------------------------------------*/
  1273.     /*----------------------------------------------------------------*/
  1274.     /* Code Body                                                      */
  1275.     /*----------------------------------------------------------------*/
  1276.     MMI_key_input_handler(KEY_8, KEY_EVENT_UP);
  1277. }
  1280. /*****************************************************************************
  1281.  * FUNCTION
  1282.  *  MMI_key_9_up
  1283.  * DESCRIPTION
  1284.  *  Handle key 9 release event
  1285.  * PARAMETERS
  1286.  *  void
  1287.  * RETURNS
  1288.  *  void
  1289.  *****************************************************************************/
  1290. void MMI_key_9_up(void)
  1291. {
  1292.     /*----------------------------------------------------------------*/
  1293.     /* Local Variables                                                */
  1294.     /*----------------------------------------------------------------*/
  1296.     /*----------------------------------------------------------------*/
  1297.     /* Code Body                                                      */
  1298.     /*----------------------------------------------------------------*/
  1299.     MMI_key_input_handler(KEY_9, KEY_EVENT_UP);
  1300. }
  1302. /* multitap for star and pound */
  1305. /*****************************************************************************
  1306.  * FUNCTION
  1307.  *  MMI_key_star_up
  1308.  * DESCRIPTION
  1309.  *  Handle key star release event
  1310.  * PARAMETERS
  1311.  *  void
  1312.  * RETURNS
  1313.  *  void
  1314.  *****************************************************************************/
  1315. void MMI_key_star_up(void)
  1316. {
  1317.     /*----------------------------------------------------------------*/
  1318.     /* Local Variables                                                */
  1319.     /*----------------------------------------------------------------*/
  1321.     /*----------------------------------------------------------------*/
  1322.     /* Code Body                                                      */
  1323.     /*----------------------------------------------------------------*/
  1324.     MMI_key_input_handler(KEY_STAR, KEY_EVENT_UP);
  1325. }
  1328. /*****************************************************************************
  1329.  * FUNCTION
  1330.  *  MMI_key_pound_up
  1331.  * DESCRIPTION
  1332.  *  Handle key pound release event
  1333.  * PARAMETERS
  1334.  *  void
  1335.  * RETURNS
  1336.  *  void
  1337.  *****************************************************************************/
  1338. void MMI_key_pound_up(void)
  1339. {
  1340.     /*----------------------------------------------------------------*/
  1341.     /* Local Variables                                                */
  1342.     /*----------------------------------------------------------------*/
  1344.     /*----------------------------------------------------------------*/
  1345.     /* Code Body                                                      */
  1346.     /*----------------------------------------------------------------*/
  1347.     MMI_key_input_handler(KEY_POUND, KEY_EVENT_UP);
  1348. }
  1350. #ifdef __MMI_MULTITAP_THAI__
  1353. /*****************************************************************************
  1354.  * FUNCTION
  1355.  *  register_MMI_key_input_extend_handler
  1356.  * DESCRIPTION
  1357.  *  Register key handlers for start and pound key.
  1358.  * PARAMETERS
  1359.  *  void
  1360.  * RETURNS
  1361.  *  void
  1362.  *****************************************************************************/
  1363. void register_MMI_key_input_extend_handler(void)
  1364. {
  1365.     /*----------------------------------------------------------------*/
  1366.     /* Local Variables                                                */
  1367.     /*----------------------------------------------------------------*/
  1369.     /*----------------------------------------------------------------*/
  1370.     /* Code Body                                                      */
  1371.     /*----------------------------------------------------------------*/
  1372.     SetKeyHandler(MMI_key_star_down, KEY_STAR, KEY_EVENT_DOWN);
  1373.     SetKeyHandler(MMI_key_star_up, KEY_STAR, KEY_EVENT_UP);
  1375.     SetKeyHandler(MMI_key_pound_down, KEY_POUND, KEY_EVENT_DOWN);
  1376.     SetKeyHandler(MMI_key_pound_up, KEY_POUND, KEY_EVENT_UP);
  1377. }
  1378. #endif /* __MMI_MULTITAP_THAI__ */ 
  1381. /*****************************************************************************
  1382.  * FUNCTION
  1383.  *  register_MMI_key_input_handler
  1384.  * DESCRIPTION
  1385.  *  Register key handlers for all digit keys
  1386.  * PARAMETERS
  1387.  *  void
  1388.  * RETURNS
  1389.  *  void
  1390.  *****************************************************************************/
  1391. void register_MMI_key_input_handler(void)
  1392. {
  1393.     /*----------------------------------------------------------------*/
  1394.     /* Local Variables                                                */
  1395.     /*----------------------------------------------------------------*/
  1397.     /*----------------------------------------------------------------*/
  1398.     /* Code Body                                                      */
  1399.     /*----------------------------------------------------------------*/
  1400.     SetKeyHandler(MMI_key_0_down, KEY_0, KEY_EVENT_DOWN);
  1401.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_EVENT_DOWN);
  1402.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_EVENT_DOWN);
  1403.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_EVENT_DOWN);
  1404.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_EVENT_DOWN);
  1405.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_EVENT_DOWN);
  1406.     SetKeyHandler(MMI_key_6_down, KEY_6, KEY_EVENT_DOWN);
  1407.     SetKeyHandler(MMI_key_7_down, KEY_7, KEY_EVENT_DOWN);
  1408.     SetKeyHandler(MMI_key_8_down, KEY_8, KEY_EVENT_DOWN);
  1409.     SetKeyHandler(MMI_key_9_down, KEY_9, KEY_EVENT_DOWN);
  1411.     SetKeyHandler(MMI_key_0_down, KEY_0, KEY_REPEAT);
  1412.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_REPEAT);
  1413.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_REPEAT);
  1414.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_REPEAT);
  1415.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_REPEAT);
  1416.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_REPEAT);
  1417.     SetKeyHandler(MMI_key_6_down, KEY_6, KEY_REPEAT);
  1418.     SetKeyHandler(MMI_key_7_down, KEY_7, KEY_REPEAT);
  1419.     SetKeyHandler(MMI_key_8_down, KEY_8, KEY_REPEAT);
  1420.     SetKeyHandler(MMI_key_9_down, KEY_9, KEY_REPEAT);
  1422.     SetKeyHandler(MMI_key_0_up, KEY_0, KEY_EVENT_UP);
  1423.     SetKeyHandler(MMI_key_1_up, KEY_1, KEY_EVENT_UP);
  1424.     SetKeyHandler(MMI_key_2_up, KEY_2, KEY_EVENT_UP);
  1425.     SetKeyHandler(MMI_key_3_up, KEY_3, KEY_EVENT_UP);
  1426.     SetKeyHandler(MMI_key_4_up, KEY_4, KEY_EVENT_UP);
  1427.     SetKeyHandler(MMI_key_5_up, KEY_5, KEY_EVENT_UP);
  1428.     SetKeyHandler(MMI_key_6_up, KEY_6, KEY_EVENT_UP);
  1429.     SetKeyHandler(MMI_key_7_up, KEY_7, KEY_EVENT_UP);
  1430.     SetKeyHandler(MMI_key_8_up, KEY_8, KEY_EVENT_UP);
  1431.     SetKeyHandler(MMI_key_9_up, KEY_9, KEY_EVENT_UP);
  1432. }
  1435. /*****************************************************************************
  1436.  * FUNCTION
  1437.  *  register_MMI_stroke_key_input_handler
  1438.  * DESCRIPTION
  1439.  *  Register key handlers for stroke input type
  1440.  * PARAMETERS
  1441.  *  void
  1442.  * RETURNS
  1443.  *  void
  1444.  *****************************************************************************/
  1445. void register_MMI_stroke_key_input_handler(void)
  1446. {
  1447. #if defined(__MMI_T9__)
  1448.     /*----------------------------------------------------------------*/
  1449.     /* Local Variables                                                */
  1450.     /*----------------------------------------------------------------*/
  1452.     /*----------------------------------------------------------------*/
  1453.     /* Code Body                                                      */
  1454.     /*----------------------------------------------------------------*/
  1455.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_EVENT_DOWN);
  1456.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_EVENT_DOWN);
  1457.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_EVENT_DOWN);
  1458.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_EVENT_DOWN);
  1459.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_EVENT_DOWN);
  1460.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_EVENT_DOWN);
  1461.     SetKeyHandler(UI_dummy_function, KEY_6, KEY_EVENT_DOWN);
  1462.     SetKeyHandler(UI_dummy_function, KEY_7, KEY_EVENT_DOWN);
  1463.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_EVENT_DOWN);
  1464.     SetKeyHandler(UI_dummy_function, KEY_9, KEY_EVENT_DOWN);
  1466.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_REPEAT);
  1467.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_REPEAT);
  1468.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_REPEAT);
  1469.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_REPEAT);
  1470.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_REPEAT);
  1471.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_REPEAT);
  1472.     SetKeyHandler(UI_dummy_function, KEY_6, KEY_REPEAT);
  1473.     SetKeyHandler(UI_dummy_function, KEY_7, KEY_REPEAT);
  1474.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_REPEAT);
  1475.     SetKeyHandler(UI_dummy_function, KEY_9, KEY_REPEAT);
  1477.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_EVENT_UP);
  1478.     SetKeyHandler(MMI_key_1_up, KEY_1, KEY_EVENT_UP);
  1479.     SetKeyHandler(MMI_key_2_up, KEY_2, KEY_EVENT_UP);
  1480.     SetKeyHandler(MMI_key_3_up, KEY_3, KEY_EVENT_UP);
  1481.     SetKeyHandler(MMI_key_4_up, KEY_4, KEY_EVENT_UP);
  1482.     SetKeyHandler(MMI_key_5_up, KEY_5, KEY_EVENT_UP);
  1483.     SetKeyHandler(UI_dummy_function, KEY_6, KEY_EVENT_UP);
  1484.     SetKeyHandler(UI_dummy_function, KEY_7, KEY_EVENT_UP);
  1485.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_EVENT_UP);
  1486.     SetKeyHandler(UI_dummy_function, KEY_9, KEY_EVENT_UP);
  1487. #elif defined(__MMI_ZI__)
  1488.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_EVENT_DOWN);
  1489.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_EVENT_DOWN);
  1490.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_EVENT_DOWN);
  1491.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_EVENT_DOWN);
  1492.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_EVENT_DOWN);
  1493.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_EVENT_DOWN);
  1494.     SetKeyHandler(MMI_key_6_down, KEY_6, KEY_EVENT_DOWN);
  1495.     SetKeyHandler(MMI_key_7_down, KEY_7, KEY_EVENT_DOWN);
  1496.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_EVENT_DOWN);
  1497.     SetKeyHandler(MMI_key_9_down, KEY_9, KEY_EVENT_DOWN);
  1499.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_REPEAT);
  1500.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_REPEAT);
  1501.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_REPEAT);
  1502.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_REPEAT);
  1503.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_REPEAT);
  1504.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_REPEAT);
  1505.     SetKeyHandler(MMI_key_6_down, KEY_6, KEY_REPEAT);
  1506.     SetKeyHandler(MMI_key_7_down, KEY_7, KEY_REPEAT);
  1507.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_REPEAT);
  1508.     SetKeyHandler(MMI_key_9_down, KEY_9, KEY_REPEAT);
  1510.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_EVENT_UP);
  1511.     SetKeyHandler(MMI_key_1_up, KEY_1, KEY_EVENT_UP);
  1512.     SetKeyHandler(MMI_key_2_up, KEY_2, KEY_EVENT_UP);
  1513.     SetKeyHandler(MMI_key_3_up, KEY_3, KEY_EVENT_UP);
  1514.     SetKeyHandler(MMI_key_4_up, KEY_4, KEY_EVENT_UP);
  1515.     SetKeyHandler(MMI_key_5_up, KEY_5, KEY_EVENT_UP);
  1516.     SetKeyHandler(MMI_key_6_up, KEY_6, KEY_EVENT_UP);
  1517.     SetKeyHandler(MMI_key_7_up, KEY_7, KEY_EVENT_UP);
  1518.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_EVENT_UP);
  1519.     SetKeyHandler(MMI_key_9_up, KEY_9, KEY_EVENT_UP);
  1521. //KP Jerry add on 2007-3-8 start
  1522. #elif defined(__MMI_CSTAR__)
  1523.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_EVENT_DOWN);
  1524.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_EVENT_DOWN);
  1525.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_EVENT_DOWN);
  1526.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_EVENT_DOWN);
  1527.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_EVENT_DOWN);
  1528.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_EVENT_DOWN);
  1529.     SetKeyHandler(UI_dummy_function, KEY_6, KEY_EVENT_DOWN);
  1530.     SetKeyHandler(UI_dummy_function, KEY_7, KEY_EVENT_DOWN);
  1531.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_EVENT_DOWN);
  1532.     SetKeyHandler(UI_dummy_function, KEY_9, KEY_EVENT_DOWN);
  1534.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_REPEAT);
  1535.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_REPEAT);
  1536.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_REPEAT);
  1537.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_REPEAT);
  1538.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_REPEAT);
  1539.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_REPEAT);
  1540.     SetKeyHandler(UI_dummy_function, KEY_6, KEY_REPEAT);
  1541.     SetKeyHandler(UI_dummy_function, KEY_7, KEY_REPEAT);
  1542.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_REPEAT);
  1543.     SetKeyHandler(UI_dummy_function, KEY_9, KEY_REPEAT);
  1545.     SetKeyHandler(UI_dummy_function, KEY_0, KEY_EVENT_UP);
  1546.     SetKeyHandler(MMI_key_1_up, KEY_1, KEY_EVENT_UP);
  1547.     SetKeyHandler(MMI_key_2_up, KEY_2, KEY_EVENT_UP);
  1548.     SetKeyHandler(MMI_key_3_up, KEY_3, KEY_EVENT_UP);
  1549.     SetKeyHandler(MMI_key_4_up, KEY_4, KEY_EVENT_UP);
  1550.     SetKeyHandler(MMI_key_5_up, KEY_5, KEY_EVENT_UP);
  1551.     SetKeyHandler(UI_dummy_function, KEY_6, KEY_EVENT_UP);
  1552.     SetKeyHandler(UI_dummy_function, KEY_7, KEY_EVENT_UP);
  1553.     SetKeyHandler(UI_dummy_function, KEY_8, KEY_EVENT_UP);
  1554.     SetKeyHandler(UI_dummy_function, KEY_9, KEY_EVENT_UP);
  1555. //KP Jerry add on 2007-3-8 end
  1557. #elif defined(__MMI_ITAP__)
  1558. /* under construction !*/
  1559. /* under construction !*/
  1560. /* under construction !*/
  1561. /* under construction !*/
  1562. /* under construction !*/
  1563. /* under construction !*/
  1564. /* under construction !*/
  1565. /* under construction !*/
  1566. /* under construction !*/
  1567. /* under construction !*/
  1568. /* under construction !*/
  1569. /* under construction !*/
  1570. /* under construction !*/
  1571. /* under construction !*/
  1572. /* under construction !*/
  1573. /* under construction !*/
  1574. /* under construction !*/
  1575. /* under construction !*/
  1576. /* under construction !*/
  1577. /* under construction !*/
  1578. /* under construction !*/
  1579. /* under construction !*/
  1580. /* under construction !*/
  1581. /* under construction !*/
  1582. /* under construction !*/
  1583. /* under construction !*/
  1584. /* under construction !*/
  1585. /* under construction !*/
  1586. /* under construction !*/
  1587. /* under construction !*/
  1588. /* under construction !*/
  1589. /* under construction !*/
  1590. #endif 
  1591. }
  1594. /*****************************************************************************
  1595.  * FUNCTION
  1596.  *  clear_MMI_key_input_handler
  1597.  * DESCRIPTION
  1598.  *  Clear key handlers for input
  1599.  * PARAMETERS
  1600.  *  void
  1601.  * RETURNS
  1602.  *  void
  1603.  *****************************************************************************/
  1604. void clear_MMI_key_input_handler(void)
  1605. {
  1606.     /*----------------------------------------------------------------*/
  1607.     /* Local Variables                                                */
  1608.     /*----------------------------------------------------------------*/
  1610.     /*----------------------------------------------------------------*/
  1611.     /* Code Body                                                      */
  1612.     /*----------------------------------------------------------------*/
  1613.     ClearKeyHandler(KEY_0, KEY_EVENT_DOWN);
  1614.     ClearKeyHandler(KEY_1, KEY_EVENT_DOWN);
  1615.     ClearKeyHandler(KEY_2, KEY_EVENT_DOWN);
  1616.     ClearKeyHandler(KEY_3, KEY_EVENT_DOWN);
  1617.     ClearKeyHandler(KEY_4, KEY_EVENT_DOWN);
  1618.     ClearKeyHandler(KEY_5, KEY_EVENT_DOWN);
  1619.     ClearKeyHandler(KEY_6, KEY_EVENT_DOWN);
  1620.     ClearKeyHandler(KEY_7, KEY_EVENT_DOWN);
  1621.     ClearKeyHandler(KEY_8, KEY_EVENT_DOWN);
  1622.     ClearKeyHandler(KEY_9, KEY_EVENT_DOWN);
  1624.     ClearKeyHandler(KEY_0, KEY_EVENT_UP);
  1625.     ClearKeyHandler(KEY_1, KEY_EVENT_UP);
  1626.     ClearKeyHandler(KEY_2, KEY_EVENT_UP);
  1627.     ClearKeyHandler(KEY_3, KEY_EVENT_UP);
  1628.     ClearKeyHandler(KEY_4, KEY_EVENT_UP);
  1629.     ClearKeyHandler(KEY_5, KEY_EVENT_UP);
  1630.     ClearKeyHandler(KEY_6, KEY_EVENT_UP);
  1631.     ClearKeyHandler(KEY_7, KEY_EVENT_UP);
  1632.     ClearKeyHandler(KEY_8, KEY_EVENT_UP);
  1633.     ClearKeyHandler(KEY_9, KEY_EVENT_UP);
  1635. }
  1637. /* Initialization / termination wrappers  */
  1640. /*****************************************************************************
  1641.  * FUNCTION
  1642.  *  wgui_init
  1643.  * DESCRIPTION
  1644.  *  Initializes the GUI wrappers
  1645.  * PARAMETERS
  1646.  *  void
  1647.  * RETURNS
  1648.  *  void
  1649.  *****************************************************************************/
  1650. void wgui_init(void)
  1651. {
  1652.     /*----------------------------------------------------------------*/
  1653.     /* Local Variables                                                */
  1654.     /*----------------------------------------------------------------*/
  1656.     /*----------------------------------------------------------------*/
  1657.     /* Code Body                                                      */
  1658.     /*----------------------------------------------------------------*/
  1659.     set_MMI_theme((MMI_theme*) MMI_themes[0]);
  1661.     gui_initialize_default_themes();
  1663. #if(!UI_DISABLE_EMS_INPUT_BOX)
  1664.     gui_intialize_EMS();
  1665. #endif 
  1667.     register_keyboard_key_handler(dummy_keyboard_key_handler);
  1668.     register_keyboard_input_handler(dummy_keyboard_input_handler);
  1669.     register_keyboard_global_key_handler(dummy_keyboard_key_handler);
  1671.     create_softkeys();
  1672.     create_menu_shortcut_handler();
  1673.     create_fixed_list();
  1674.     create_fixed_matrix();
  1675.     create_multitaps();
  1676.     create_virtual_keyboard();
  1678.     clear_key_input_handler();
  1679.     clear_key_down_handler();
  1680.     clear_key_up_handler();
  1681.     initialize_status_icons();
  1682.     hide_multitap = UI_dummy_function;
  1683.     register_multiline_inputbox_input_callback(UI_dummy_function);
  1684. }