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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
wgui.c
资源名称：FreetypeSetting.rar　[点击查看]
上传用户：dengyu
上传日期：2022-05-01
资源大小：153k
文件大小：64k
源码类别：

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.  *
  93.  * removed!
  94.  * removed!
  95.  * removed!
  96.  *
  97.  * removed!
  98.  * removed!
  99.  * removed!
  100.  *
  101.  * removed!
  102.  * removed!
  103.  * removed!
  104.  *
  105.  * removed!
  106.  * removed!
  107.  * removed!
  108.  *
  109.  * removed!
  110.  * removed!
  111.  * removed!
  112.  *
  113.  * removed!
  114.  * removed!
  115.  * removed!
  116.  *
  117.  * removed!
  118.  * removed!
  119.  * removed!
  120.  *
  121.  * removed!
  122.  * removed!
  123.  * removed!
  124.  *
  125.  * removed!
  126.  * removed!
  127.  * removed!
  128.  *
  129.  * removed!
  130.  * removed!
  131.  * removed!
  132.  *
  133.  * removed!
  134.  * removed!
  135.  * removed!
  136.  *
  137.  * removed!
  138.  * removed!
  139.  * removed!
  140.  *
  141.  * removed!
  142.  * removed!
  143.  * removed!
  144.  *
  145.  * removed!
  146.  * removed!
  147.  * removed!
  148.  *
  149.  * removed!
  150.  * removed!
  151.  * removed!
  152.  *
  153.  * removed!
  154.  * removed!
  155.  * removed!
  156.  *
  157.  * removed!
  158.  * removed!
  159.  * removed!
  160.  *
  161.  * removed!
  162.  * removed!
  163.  * removed!
  164.  *
  165.  * removed!
  166.  * removed!
  167.  * removed!
  168.  *
  169.  * removed!
  170.  * removed!
  171.  * removed!
  172.  *
  173.  * removed!
  174.  * removed!
  175.  * removed!
  176.  *
  177.  * removed!
  178.  * removed!
  179.  * removed!
  180.  *
  181.  * removed!
  182.  * removed!
  183.  * removed!
  184.  *
  185.  * removed!
  186.  * removed!
  187.  * removed!
  188.  *
  189.  * removed!
  190.  * removed!
  191.  * removed!
  192.  *
  193.  * removed!
  194.  * removed!
  195.  * removed!
  196.  *
  197.  * removed!
  198.  * removed!
  199.  * removed!
  200.  *
  201.  * removed!
  202.  * removed!
  203.  * removed!
  204.  *
  205.  * removed!
  206.  * removed!
  207.  * removed!
  208.  *
  209.  * removed!
  210.  * removed!
  211.  * removed!
  212.  * removed!
  213.  *
  214.  * removed!
  215.  * removed!
  216.  * removed!
  217.  * removed!
  218.  * removed!
  219.  */
  221. /**********************************************************************************
  222.    Filename:      wgui.c
  223.    Author:        manju
  224.    Date Created:  August-07-2002
  225.    Contains:      PixTel UI wrapper routines
  226.                Contains several parts and has been split to multiple
  227.                code files. See other files named wgui_*.c and wgui_*.h
  228.                This file contains common functions and data.
  229. **********************************************************************************/
  231. /* Include: MMI header file */
  232. #include "mmi_frm_gprot.h"
  233. #include "WguiCategoryGprot.h"
  234. #include "wgui_fixed_menuitems.h"
  235. #include "wgui_virtual_keyboard.h"
  236. #include "IdleAppDef.h"
  237. #include "FunAndGamesDefs.h"
  238. #if(!UI_DISABLE_EMS_INPUT_BOX)
  239. #endif 
  241. #ifdef __MMI_VUI_ENGINE__
  242. extern void vrt_canvas_suspend();
  243. #endif    
  246. #include "wgui_softkeys.h"
  247. /* 
  248.  * removed!
  249.  */
  250. static void (*MMI_keyboard_key_handler) (S32 vkey_code, S32 key_state) = NULL;
  251. static void (*MMI_keyboard_input_handler) (S32 vkey_code) = NULL;
  252. static void (*MMI_keyboard_global_key_handler) (S32 vkey_code, S32 key_state) = NULL;
  253. static void (*MMI_keyboard_global_input_handler) (S32 vkey_code) = NULL;
  254. static void (*MMI_key_input_handler_function) (MMI_key_code_type key_code, MMI_key_event_type key_event);
  255. static void (*MMI_key_down_handler_function) (MMI_key_code_type key_code);
  256. static void (*MMI_key_up_handler_function) (MMI_key_code_type key_code);
  258. /* 
  259.  * removed!
  260.  */
  261. S32 MMI_status_bar_height;
  262. S32 MMI_content_x;
  263. S32 MMI_content_y;
  264. S32 MMI_content_width;
  265. S32 MMI_content_height;
  267. extern MMI_theme **MMI_themes;
  269. /* 
  270.  * removed!
  271.  */
  274. /*****************************************************************************
  275.  * removed!
  276.  * removed!
  277.  * removed!
  278.  * removed!
  279.  * removed!
  280.  * removed!
  281.  * removed!
  282.  * removed!
  283.  *****************************************************************************/
  284. void MMI_dummy_function(void)
  285. {
  286.     /*----------------------------------------------------------------*/
  287.     /* Local Variables                                                */
  288.     /*----------------------------------------------------------------*/
  290.     /*----------------------------------------------------------------*/
  291.     /* Code Body                                                      */
  292.     /*----------------------------------------------------------------*/
  293. }
  295. /* Functions for keyboard Support   */
  298. /*****************************************************************************
  299.  * FUNCTION
  300.  *  dummy_keyboard_key_handler
  301.  * DESCRIPTION
  302.  *  Dummy keyboard key handler
  303.  * PARAMETERS
  304.  *  vkey_code       [IN]        Key_code
  305.  *  key_state       [IN]        Key_state
  306.  * RETURNS
  307.  *  void
  308.  *****************************************************************************/
  309. void dummy_keyboard_key_handler(S32 vkey_code, S32 key_state)
  310. {
  311.     /*----------------------------------------------------------------*/
  312.     /* Local Variables                                                */
  313.     /*----------------------------------------------------------------*/
  315.     /*----------------------------------------------------------------*/
  316.     /* Code Body                                                      */
  317.     /*----------------------------------------------------------------*/
  318.     UI_UNUSED_PARAMETER(vkey_code);
  319.     UI_UNUSED_PARAMETER(key_state);
  320. }
  323. /*****************************************************************************
  324.  * FUNCTION
  325.  *  dummy_keyboard_input_handler
  326.  * DESCRIPTION
  327.  *  Dummy keyboard input handler
  328.  * PARAMETERS
  329.  *  vkey_code       [IN]        Key_code
  330.  * RETURNS
  331.  *  void
  332.  *****************************************************************************/
  333. void dummy_keyboard_input_handler(S32 vkey_code)
  334. {
  335.     /*----------------------------------------------------------------*/
  336.     /* Local Variables                                                */
  337.     /*----------------------------------------------------------------*/
  339.     /*----------------------------------------------------------------*/
  340.     /* Code Body                                                      */
  341.     /*----------------------------------------------------------------*/
  342.     UI_UNUSED_PARAMETER(vkey_code);
  343. }
  346. /*****************************************************************************
  347.  * FUNCTION
  348.  *  keyboard_key_handler
  349.  * DESCRIPTION
  350.  *  Handles key events (UP/DOWN)
  351.  * PARAMETERS
  352.  *  vkey_code       [IN]        Key's scan code
  353.  *  key_state       [IN]        Key's state (up or down)
  354.  * RETURNS
  355.  *  void
  356.  *****************************************************************************/
  357. void keyboard_key_handler(S32 vkey_code, S32 key_state)
  358. {
  359.     /*----------------------------------------------------------------*/
  360.     /* Local Variables                                                */
  361.     /*----------------------------------------------------------------*/
  362.     U8 state = 0;
  364.     /*----------------------------------------------------------------*/
  365.     /* Code Body                                                      */
  366.     /*----------------------------------------------------------------*/
  367.     /* Perform scan code and key state mapping here */
  368.     if (key_state == KEYBOARD_KEY_DOWN)
  369.     {
  370.         state = 1;
  371.     }
  372.     else if (key_state == KEYBOARD_KEY_UP)
  373.     {
  374.         state = 0;
  375.     }
  376.     if (MMI_keyboard_key_handler != NULL)
  377.     {
  378.         MMI_keyboard_key_handler(vkey_code, state);
  379.     }
  380. }
  383. /*****************************************************************************
  384.  * FUNCTION
  385.  *  keyboard_input_handler
  386.  * DESCRIPTION
  387.  *  Handles keyboard input
  388.  * PARAMETERS
  389.  *  vkey_code       [IN]        Key's character code (ASCII)
  390.  * RETURNS
  391.  *  void
  392.  *****************************************************************************/
  393. void keyboard_input_handler(S32 vkey_code)
  394. {
  395.     /*----------------------------------------------------------------*/
  396.     /* Local Variables                                                */
  397.     /*----------------------------------------------------------------*/
  399.     /*----------------------------------------------------------------*/
  400.     /* Code Body                                                      */
  401.     /*----------------------------------------------------------------*/
  402.     if (MMI_keyboard_input_handler != NULL)
  403.     {
  404.         MMI_keyboard_input_handler(vkey_code);
  405.     }
  406. }
  409. /*****************************************************************************
  410.  * FUNCTION
  411.  *  keyboard_global_key_handler
  412.  * DESCRIPTION
  413.  *  Handles key events (UP/DOWN)
  414.  * PARAMETERS
  415.  *  vkey_code       [IN]        Key's scan code
  416.  *  key_state       [IN]        Key's state (up or down)
  417.  * RETURNS
  418.  *  void
  419.  *****************************************************************************/
  420. void keyboard_global_key_handler(S32 vkey_code, S32 key_state)
  421. {
  422.     /*----------------------------------------------------------------*/
  423.     /* Local Variables                                                */
  424.     /*----------------------------------------------------------------*/
  425.     U8 state = 0;
  427.     /*----------------------------------------------------------------*/
  428.     /* Code Body                                                      */
  429.     /*----------------------------------------------------------------*/
  430.     /* Perform scan code and key state mapping here */
  431.     if (key_state == KEYBOARD_KEY_DOWN)
  432.     {
  433.         state = 1;
  434.     }
  435.     else if (key_state == KEYBOARD_KEY_UP)
  436.     {
  437.         state = 0;
  438.     }
  440.     if (MMI_keyboard_global_key_handler != NULL)
  441.     {
  442.         MMI_keyboard_global_key_handler(vkey_code, state);
  443.     }
  444. }
  447. /*****************************************************************************
  448.  * FUNCTION
  449.  *  keyboard_global_input_handler
  450.  * DESCRIPTION
  451.  *  Handles keyboard input
  452.  * PARAMETERS
  453.  *  vkey_code       [IN]        Key's character code (ASCII)
  454.  * RETURNS
  455.  *  void
  456.  *****************************************************************************/
  457. void keyboard_global_input_handler(S32 vkey_code)
  458. {
  459.     /*----------------------------------------------------------------*/
  460.     /* Local Variables                                                */
  461.     /*----------------------------------------------------------------*/
  463.     /*----------------------------------------------------------------*/
  464.     /* Code Body                                                      */
  465.     /*----------------------------------------------------------------*/
  466.     if (MMI_keyboard_global_input_handler != NULL)
  467.     {
  468.         MMI_keyboard_global_input_handler(vkey_code);
  469.     }
  470. }
  473. /*****************************************************************************
  474.  * FUNCTION
  475.  *  register_keyboard_key_handler
  476.  * DESCRIPTION
  477.  *  Registers a function to be called for key handling
  478.  * PARAMETERS
  479.  *  f       [IN]        Function to be called for key handling
  480.  * RETURNS
  481.  *  void
  482.  *****************************************************************************/
  483. void register_keyboard_key_handler(void (*f) (S32 vkey_code, S32 key_state))
  484. {
  485.     /*----------------------------------------------------------------*/
  486.     /* Local Variables                                                */
  487.     /*----------------------------------------------------------------*/
  489.     /*----------------------------------------------------------------*/
  490.     /* Code Body                                                      */
  491.     /*----------------------------------------------------------------*/
  492.     MMI_keyboard_key_handler = f;
  493. }
  496. /*****************************************************************************
  497.  * FUNCTION
  498.  *  register_keyboard_input_handler
  499.  * DESCRIPTION
  500.  *  Registers a function to be called for key input
  501.  * PARAMETERS
  502.  *  f       [IN]        Function that is called upon key events
  503.  * RETURNS
  504.  *  void
  505.  *****************************************************************************/
  506. void register_keyboard_input_handler(void (*f) (S32 vkey_code))
  507. {
  508.     /*----------------------------------------------------------------*/
  509.     /* Local Variables                                                */
  510.     /*----------------------------------------------------------------*/
  512.     /*----------------------------------------------------------------*/
  513.     /* Code Body                                                      */
  514.     /*----------------------------------------------------------------*/
  515.     MMI_keyboard_input_handler = f;
  516. }
  519. /*****************************************************************************
  520.  * FUNCTION
  521.  *  register_keyboard_global_key_handler
  522.  * DESCRIPTION
  523.  *  Registers a function to be called for key handling
  524.  * PARAMETERS
  525.  *  f       [IN]        Function that is called upon key events
  526.  * RETURNS
  527.  *  void
  528.  *****************************************************************************/
  529. void register_keyboard_global_key_handler(void (*f) (S32 vkey_code, S32 key_state))
  530. {
  531.     /*----------------------------------------------------------------*/
  532.     /* Local Variables                                                */
  533.     /*----------------------------------------------------------------*/
  535.     /*----------------------------------------------------------------*/
  536.     /* Code Body                                                      */
  537.     /*----------------------------------------------------------------*/
  538.     MMI_keyboard_global_key_handler = f;
  539. }
  542. /*****************************************************************************
  543.  * FUNCTION
  544.  *  register_keyboard_global_input_handler
  545.  * DESCRIPTION
  546.  *  Register_keyboard_global_input_handler
  547.  * PARAMETERS
  548.  *  f       [IN]        Function that is called upon key events
  549.  * RETURNS
  550.  *  void
  551.  *****************************************************************************/
  552. void register_keyboard_global_input_handler(void (*f) (S32 vkey_code))
  553. {
  554.     /*----------------------------------------------------------------*/
  555.     /* Local Variables                                                */
  556.     /*----------------------------------------------------------------*/
  558.     /*----------------------------------------------------------------*/
  559.     /* Code Body                                                      */
  560.     /*----------------------------------------------------------------*/
  561.     MMI_keyboard_global_input_handler = f;
  562. }
  565. /*****************************************************************************
  566.  * FUNCTION
  567.  *  clear_keyboard_key_handler
  568.  * DESCRIPTION
  569.  *  Clears the function called to handle key events
  570.  * PARAMETERS
  571.  *  void
  572.  * RETURNS
  573.  *  void
  574.  *****************************************************************************/
  575. void clear_keyboard_key_handler(void)
  576. {
  577.     /*----------------------------------------------------------------*/
  578.     /* Local Variables                                                */
  579.     /*----------------------------------------------------------------*/
  581.     /*----------------------------------------------------------------*/
  582.     /* Code Body                                                      */
  583.     /*----------------------------------------------------------------*/
  584.     MMI_keyboard_key_handler = dummy_keyboard_key_handler;
  585. }
  588. /*****************************************************************************
  589.  * FUNCTION
  590.  *  clear_keyboard_input_handler
  591.  * DESCRIPTION
  592.  *  Clears the function called to handle key input
  593.  * PARAMETERS
  594.  *  void
  595.  * RETURNS
  596.  *  void
  597.  *****************************************************************************/
  598. void clear_keyboard_input_handler(void)
  599. {
  600.     /*----------------------------------------------------------------*/
  601.     /* Local Variables                                                */
  602.     /*----------------------------------------------------------------*/
  604.     /*----------------------------------------------------------------*/
  605.     /* Code Body                                                      */
  606.     /*----------------------------------------------------------------*/
  607.     MMI_keyboard_input_handler = dummy_keyboard_input_handler;
  608. }
  611. /*****************************************************************************
  612.  * FUNCTION
  613.  *  clear_keyboard_global_key_handler
  614.  * DESCRIPTION
  615.  *  Clears the function called to handle key events
  616.  * PARAMETERS
  617.  *  void
  618.  * RETURNS
  619.  *  void
  620.  *****************************************************************************/
  621. void clear_keyboard_global_key_handler(void)
  622. {
  623.     /*----------------------------------------------------------------*/
  624.     /* Local Variables                                                */
  625.     /*----------------------------------------------------------------*/
  627.     /*----------------------------------------------------------------*/
  628.     /* Code Body                                                      */
  629.     /*----------------------------------------------------------------*/
  630.     MMI_keyboard_global_key_handler = dummy_keyboard_key_handler;
  631. }
  634. /*****************************************************************************
  635.  * FUNCTION
  636.  *  clear_keyboard_global_input_handler
  637.  * DESCRIPTION
  638.  *  Clears the function called to handle key input
  639.  * PARAMETERS
  640.  *  void
  641.  * RETURNS
  642.  *  void
  643.  *****************************************************************************/
  644. void clear_keyboard_global_input_handler(void)
  645. {
  646.     /*----------------------------------------------------------------*/
  647.     /* Local Variables                                                */
  648.     /*----------------------------------------------------------------*/
  650.     /*----------------------------------------------------------------*/
  651.     /* Code Body                                                      */
  652.     /*----------------------------------------------------------------*/
  653.     MMI_keyboard_global_input_handler = dummy_keyboard_input_handler;
  654. }
  656. /* Key handling wrappers      */
  659. /*****************************************************************************
  660.  * FUNCTION
  661.  *  clear_key_handlers
  662.  * DESCRIPTION
  663.  *  Clears the key handlers
  664.  * PARAMETERS
  665.  *  void
  666.  * RETURNS
  667.  *  void
  668.  *****************************************************************************/
  669. void clear_key_handlers(void)
  670. {
  671.     /*----------------------------------------------------------------*/
  672.     /* Local Variables                                                */
  673.     /*----------------------------------------------------------------*/
  675.     /*----------------------------------------------------------------*/
  676.     /* Code Body                                                      */
  677.     /*----------------------------------------------------------------*/
  678.     clear_softkey_handler(MMI_LEFT_SOFTKEY);
  679.     clear_softkey_handler(MMI_RIGHT_SOFTKEY);
  680. #ifdef __MMI_WGUI_CSK_ENABLE__
  681.     clear_softkey_handler(MMI_CENTER_SOFTKEY);
  682. #endif 
  683.     register_keyboard_key_handler(dummy_keyboard_key_handler);
  684.     register_keyboard_input_handler(dummy_keyboard_input_handler);
  685.     register_keyboard_global_input_handler(dummy_keyboard_input_handler);
  686.     ClearInputEventHandler(MMI_DEVICE_KEY);
  687. }
  690. /*****************************************************************************
  691.  * FUNCTION
  692.  *  clear_category_screen_key_handlers
  693.  * DESCRIPTION
  694.  *  Clears the key handlers used in category screen
  695.  * PARAMETERS
  696.  *  void
  697.  * RETURNS
  698.  *  void
  699.  *****************************************************************************/
  700. void clear_category_screen_key_handlers(void)
  701. {
  702.     /*----------------------------------------------------------------*/
  703.     /* Local Variables                                                */
  704.     /*----------------------------------------------------------------*/
  706.     /*----------------------------------------------------------------*/
  707.     /* Code Body                                                      */
  708.     /*----------------------------------------------------------------*/
  709.     clear_softkey_handler(MMI_LEFT_SOFTKEY);
  710.     clear_softkey_handler(MMI_RIGHT_SOFTKEY);
  711. #ifdef __MMI_WGUI_CSK_ENABLE__
  712.     clear_softkey_handler(MMI_CENTER_SOFTKEY);
  713. #endif 
  714.     register_keyboard_key_handler(dummy_keyboard_key_handler);
  715.     register_keyboard_input_handler(dummy_keyboard_input_handler);
  716. }
  719. /*****************************************************************************
  720.  * FUNCTION
  721.  *  register_key_input_handler
  722.  * DESCRIPTION
  723.  *  Registers a key input handler for a keypad key
  724.  * PARAMETERS
  725.  *  f       [IN]        Function that is called on receiving key events
  726.  * RETURNS
  727.  *  void
  728.  *****************************************************************************/
  729. void register_key_input_handler(void (*f) (MMI_key_code_type key_code, MMI_key_event_type key_event))
  730. {
  731.     /*----------------------------------------------------------------*/
  732.     /* Local Variables                                                */
  733.     /*----------------------------------------------------------------*/
  735.     /*----------------------------------------------------------------*/
  736.     /* Code Body                                                      */
  737.     /*----------------------------------------------------------------*/
  738.     MMI_key_input_handler_function = f;
  739. }
  742. /*****************************************************************************
  743.  * FUNCTION
  744.  *  register_key_up_handler
  745.  * DESCRIPTION
  746.  *  Registers handler for the key up events of all keys
  747.  * PARAMETERS
  748.  *  f       [IN]        Function that is called whenever any key is released
  749.  * RETURNS
  750.  *  void
  751.  *****************************************************************************/
  752. void register_key_up_handler(void (*f) (MMI_key_code_type key_code))
  753. {
  754.     /*----------------------------------------------------------------*/
  755.     /* Local Variables                                                */
  756.     /*----------------------------------------------------------------*/
  758.     /*----------------------------------------------------------------*/
  759.     /* Code Body                                                      */
  760.     /*----------------------------------------------------------------*/
  761.     MMI_key_up_handler_function = f;
  762. }
  765. /*****************************************************************************
  766.  * FUNCTION
  767.  *  register_key_down_handler
  768.  * DESCRIPTION
  769.  *  Registers handler for the key down events of all keys
  770.  * PARAMETERS
  771.  *  f       [IN]        Function that is called whenever any key is pressed
  772.  * RETURNS
  773.  *  void
  774.  *****************************************************************************/
  775. void register_key_down_handler(void (*f) (MMI_key_code_type key_code))
  776. {
  777.     /*----------------------------------------------------------------*/
  778.     /* Local Variables                                                */
  779.     /*----------------------------------------------------------------*/
  781.     /*----------------------------------------------------------------*/
  782.     /* Code Body                                                      */
  783.     /*----------------------------------------------------------------*/
  784.     MMI_key_down_handler_function = f;
  785. }
  788. /*****************************************************************************
  789.  * FUNCTION
  790.  *  clear_key_input_handler
  791.  * DESCRIPTION
  792.  *  Clears the key input handler
  793.  * PARAMETERS
  794.  *  void
  795.  * RETURNS
  796.  *  void
  797.  *****************************************************************************/
  798. void clear_key_input_handler(void)
  799. {
  800.     /*----------------------------------------------------------------*/
  801.     /* Local Variables                                                */
  802.     /*----------------------------------------------------------------*/
  804.     /*----------------------------------------------------------------*/
  805.     /* Code Body                                                      */
  806.     /*----------------------------------------------------------------*/
  807.     MMI_key_input_handler_function = NULL;
  808. }
  811. /*****************************************************************************
  812.  * FUNCTION
  813.  *  clear_key_down_handler
  814.  * DESCRIPTION
  815.  *  Clears the key down handler
  816.  * PARAMETERS
  817.  *  void
  818.  * RETURNS
  819.  *  void
  820.  *****************************************************************************/
  821. void clear_key_down_handler(void)
  822. {
  823.     /*----------------------------------------------------------------*/
  824.     /* Local Variables                                                */
  825.     /*----------------------------------------------------------------*/
  827.     /*----------------------------------------------------------------*/
  828.     /* Code Body                                                      */
  829.     /*----------------------------------------------------------------*/
  830.     MMI_key_down_handler_function = NULL;
  831. }
  834. /*****************************************************************************
  835.  * FUNCTION
  836.  *  clear_key_up_handler
  837.  * DESCRIPTION
  838.  *  Clears the key up handler
  839.  * PARAMETERS
  840.  *  void
  841.  * RETURNS
  842.  *  void
  843.  *****************************************************************************/
  844. void clear_key_up_handler(void)
  845. {
  846.     /*----------------------------------------------------------------*/
  847.     /* Local Variables                                                */
  848.     /*----------------------------------------------------------------*/
  850.     /*----------------------------------------------------------------*/
  851.     /* Code Body                                                      */
  852.     /*----------------------------------------------------------------*/
  853.     MMI_key_up_handler_function = NULL;
  854. }
  856. /*----------------------------------------------------------------------------
  857.    The following functions are used internally and are not meant to be called
  858.    by other functions.
  859. ----------------------------------------------------------------------------*/
  862. /*****************************************************************************
  863.  * FUNCTION
  864.  *  MMI_key_input_handler
  865.  * DESCRIPTION
  866.  *  Handler key input events
  867.  * PARAMETERS
  868.  *  key_code        [IN]        
  869.  *  key_event       [IN]        
  870.  * RETURNS
  871.  *  void
  872.  *****************************************************************************/
  873. void MMI_key_input_handler(MMI_key_code_type key_code, MMI_key_event_type key_event)
  874. {
  875.     /*----------------------------------------------------------------*/
  876.     /* Local Variables                                                */
  877.     /*----------------------------------------------------------------*/
  879.     /*----------------------------------------------------------------*/
  880.     /* Code Body                                                      */
  881.     /*----------------------------------------------------------------*/
  882.     if (MMI_key_input_handler_function != NULL)
  883.     {
  884.         MMI_key_input_handler_function(key_code, key_event);
  885.     }
  887.     switch (key_event)
  888.     {
  889.         case KEY_EVENT_DOWN:
  890.             if (MMI_key_down_handler_function != NULL)
  891.             {
  892.                 MMI_key_down_handler_function(key_code);
  893.             }
  894.             break;
  895.         case KEY_EVENT_UP:
  896.             if (MMI_key_up_handler_function != NULL)
  897.             {
  898.                 MMI_key_up_handler_function(key_code);
  899.             }
  900.             break;
  901.     }
  902. }
  905. /*****************************************************************************
  906.  * FUNCTION
  907.  *  MMI_key_0_down
  908.  * DESCRIPTION
  909.  *  Handle key 0 pressed event
  910.  * PARAMETERS
  911.  *  void
  912.  * RETURNS
  913.  *  void
  914.  *****************************************************************************/
  915. void MMI_key_0_down(void)
  916. {
  917.     /*----------------------------------------------------------------*/
  918.     /* Local Variables                                                */
  919.     /*----------------------------------------------------------------*/
  921.     /*----------------------------------------------------------------*/
  922.     /* Code Body                                                      */
  923.     /*----------------------------------------------------------------*/
  924.     MMI_key_input_handler(KEY_0, KEY_EVENT_DOWN);
  925. }
  928. /*****************************************************************************
  929.  * FUNCTION
  930.  *  MMI_key_1_down
  931.  * DESCRIPTION
  932.  *  Handle key 1 pressed event
  933.  * PARAMETERS
  934.  *  void
  935.  * RETURNS
  936.  *  void
  937.  *****************************************************************************/
  938. void MMI_key_1_down(void)
  939. {
  940.     /*----------------------------------------------------------------*/
  941.     /* Local Variables                                                */
  942.     /*----------------------------------------------------------------*/
  944.     /*----------------------------------------------------------------*/
  945.     /* Code Body                                                      */
  946.     /*----------------------------------------------------------------*/
  947.     MMI_key_input_handler(KEY_1, KEY_EVENT_DOWN);
  948. }
  951. /*****************************************************************************
  952.  * FUNCTION
  953.  *  MMI_key_2_down
  954.  * DESCRIPTION
  955.  *  Handle key 2 pressed event
  956.  * PARAMETERS
  957.  *  void
  958.  * RETURNS
  959.  *  void
  960.  *****************************************************************************/
  961. void MMI_key_2_down(void)
  962. {
  963.     /*----------------------------------------------------------------*/
  964.     /* Local Variables                                                */
  965.     /*----------------------------------------------------------------*/
  967.     /*----------------------------------------------------------------*/
  968.     /* Code Body                                                      */
  969.     /*----------------------------------------------------------------*/
  970.     MMI_key_input_handler(KEY_2, KEY_EVENT_DOWN);
  971. }
  974. /*****************************************************************************
  975.  * FUNCTION
  976.  *  MMI_key_3_down
  977.  * DESCRIPTION
  978.  *  Handle key 3 pressed event
  979.  * PARAMETERS
  980.  *  void
  981.  * RETURNS
  982.  *  void
  983.  *****************************************************************************/
  984. void MMI_key_3_down(void)
  985. {
  986.     /*----------------------------------------------------------------*/
  987.     /* Local Variables                                                */
  988.     /*----------------------------------------------------------------*/
  990.     /*----------------------------------------------------------------*/
  991.     /* Code Body                                                      */
  992.     /*----------------------------------------------------------------*/
  993.     MMI_key_input_handler(KEY_3, KEY_EVENT_DOWN);
  994. }
  997. /*****************************************************************************
  998.  * FUNCTION
  999.  *  MMI_key_4_down
  1000.  * DESCRIPTION
  1001.  *  Handle key 4 pressed event
  1002.  * PARAMETERS
  1003.  *  void
  1004.  * RETURNS
  1005.  *  void
  1006.  *****************************************************************************/
  1007. void MMI_key_4_down(void)
  1008. {
  1009.     /*----------------------------------------------------------------*/
  1010.     /* Local Variables                                                */
  1011.     /*----------------------------------------------------------------*/
  1013.     /*----------------------------------------------------------------*/
  1014.     /* Code Body                                                      */
  1015.     /*----------------------------------------------------------------*/
  1016.     MMI_key_input_handler(KEY_4, KEY_EVENT_DOWN);
  1017. }
  1020. /*****************************************************************************
  1021.  * FUNCTION
  1022.  *  MMI_key_5_down
  1023.  * DESCRIPTION
  1024.  *  Handle key 5 pressed event
  1025.  * PARAMETERS
  1026.  *  void
  1027.  * RETURNS
  1028.  *  void
  1029.  *****************************************************************************/
  1030. void MMI_key_5_down(void)
  1031. {
  1032.     /*----------------------------------------------------------------*/
  1033.     /* Local Variables                                                */
  1034.     /*----------------------------------------------------------------*/
  1036.     /*----------------------------------------------------------------*/
  1037.     /* Code Body                                                      */
  1038.     /*----------------------------------------------------------------*/
  1039.     MMI_key_input_handler(KEY_5, KEY_EVENT_DOWN);
  1040. }
  1043. /*****************************************************************************
  1044.  * FUNCTION
  1045.  *  MMI_key_6_down
  1046.  * DESCRIPTION
  1047.  *  Handle key 6 pressed event
  1048.  * PARAMETERS
  1049.  *  void
  1050.  * RETURNS
  1051.  *  void
  1052.  *****************************************************************************/
  1053. void MMI_key_6_down(void)
  1054. {
  1055.     /*----------------------------------------------------------------*/
  1056.     /* Local Variables                                                */
  1057.     /*----------------------------------------------------------------*/
  1059.     /*----------------------------------------------------------------*/
  1060.     /* Code Body                                                      */
  1061.     /*----------------------------------------------------------------*/
  1062.     MMI_key_input_handler(KEY_6, KEY_EVENT_DOWN);
  1063. }
  1066. /*****************************************************************************
  1067.  * FUNCTION
  1068.  *  MMI_key_7_down
  1069.  * DESCRIPTION
  1070.  *  Handle key 7 pressed event
  1071.  * PARAMETERS
  1072.  *  void
  1073.  * RETURNS
  1074.  *  void
  1075.  *****************************************************************************/
  1076. void MMI_key_7_down(void)
  1077. {
  1078.     /*----------------------------------------------------------------*/
  1079.     /* Local Variables                                                */
  1080.     /*----------------------------------------------------------------*/
  1082.     /*----------------------------------------------------------------*/
  1083.     /* Code Body                                                      */
  1084.     /*----------------------------------------------------------------*/
  1085.     MMI_key_input_handler(KEY_7, KEY_EVENT_DOWN);
  1086. }
  1089. /*****************************************************************************
  1090.  * FUNCTION
  1091.  *  MMI_key_8_down
  1092.  * DESCRIPTION
  1093.  *  Handle key 8 pressed event
  1094.  * PARAMETERS
  1095.  *  void
  1096.  * RETURNS
  1097.  *  void
  1098.  *****************************************************************************/
  1099. void MMI_key_8_down(void)
  1100. {
  1101.     /*----------------------------------------------------------------*/
  1102.     /* Local Variables                                                */
  1103.     /*----------------------------------------------------------------*/
  1105.     /*----------------------------------------------------------------*/
  1106.     /* Code Body                                                      */
  1107.     /*----------------------------------------------------------------*/
  1108.     MMI_key_input_handler(KEY_8, KEY_EVENT_DOWN);
  1109. }
  1112. /*****************************************************************************
  1113.  * FUNCTION
  1114.  *  MMI_key_9_down
  1115.  * DESCRIPTION
  1116.  *  Handle key 9 pressed event
  1117.  * PARAMETERS
  1118.  *  void
  1119.  * RETURNS
  1120.  *  void
  1121.  *****************************************************************************/
  1122. void MMI_key_9_down(void)
  1123. {
  1124.     /*----------------------------------------------------------------*/
  1125.     /* Local Variables                                                */
  1126.     /*----------------------------------------------------------------*/
  1128.     /*----------------------------------------------------------------*/
  1129.     /* Code Body                                                      */
  1130.     /*----------------------------------------------------------------*/
  1131.     MMI_key_input_handler(KEY_9, KEY_EVENT_DOWN);
  1132. }
  1134. /* multitap for star and Pound */
  1137. /*****************************************************************************
  1138.  * FUNCTION
  1139.  *  MMI_key_star_down
  1140.  * DESCRIPTION
  1141.  *  Handle key star pressed event
  1142.  * PARAMETERS
  1143.  *  void
  1144.  * RETURNS
  1145.  *  void
  1146.  *****************************************************************************/
  1147. void MMI_key_star_down(void)
  1148. {
  1149.     /*----------------------------------------------------------------*/
  1150.     /* Local Variables                                                */
  1151.     /*----------------------------------------------------------------*/
  1153.     /*----------------------------------------------------------------*/
  1154.     /* Code Body                                                      */
  1155.     /*----------------------------------------------------------------*/
  1156.     MMI_key_input_handler(KEY_STAR, KEY_EVENT_DOWN);
  1157. }
  1160. /*****************************************************************************
  1161.  * FUNCTION
  1162.  *  MMI_key_pound_down
  1163.  * DESCRIPTION
  1164.  *  Handle key pound pressed event
  1165.  * PARAMETERS
  1166.  *  void
  1167.  * RETURNS
  1168.  *  void
  1169.  *****************************************************************************/
  1170. void MMI_key_pound_down(void)
  1171. {
  1172.     /*----------------------------------------------------------------*/
  1173.     /* Local Variables                                                */
  1174.     /*----------------------------------------------------------------*/
  1176.     /*----------------------------------------------------------------*/
  1177.     /* Code Body                                                      */
  1178.     /*----------------------------------------------------------------*/
  1179.     MMI_key_input_handler(KEY_POUND, KEY_EVENT_DOWN);
  1180. }
  1183. /*****************************************************************************
  1184.  * FUNCTION
  1185.  *  MMI_key_0_up
  1186.  * DESCRIPTION
  1187.  *  Handle key 0 release event
  1188.  * PARAMETERS
  1189.  *  void
  1190.  * RETURNS
  1191.  *  void
  1192.  *****************************************************************************/
  1193. void MMI_key_0_up(void)
  1194. {
  1195.     /*----------------------------------------------------------------*/
  1196.     /* Local Variables                                                */
  1197.     /*----------------------------------------------------------------*/
  1199.     /*----------------------------------------------------------------*/
  1200.     /* Code Body                                                      */
  1201.     /*----------------------------------------------------------------*/
  1202.     MMI_key_input_handler(KEY_0, KEY_EVENT_UP);
  1203. }
  1206. /*****************************************************************************
  1207.  * FUNCTION
  1208.  *  MMI_key_1_up
  1209.  * DESCRIPTION
  1210.  *  Handle key 1 release event
  1211.  * PARAMETERS
  1212.  *  void
  1213.  * RETURNS
  1214.  *  void
  1215.  *****************************************************************************/
  1216. void MMI_key_1_up(void)
  1217. {
  1218.     /*----------------------------------------------------------------*/
  1219.     /* Local Variables                                                */
  1220.     /*----------------------------------------------------------------*/
  1222.     /*----------------------------------------------------------------*/
  1223.     /* Code Body                                                      */
  1224.     /*----------------------------------------------------------------*/
  1225.     MMI_key_input_handler(KEY_1, KEY_EVENT_UP);
  1226. }
  1229. /*****************************************************************************
  1230.  * FUNCTION
  1231.  *  MMI_key_2_up
  1232.  * DESCRIPTION
  1233.  *  Handle key 2 release event
  1234.  * PARAMETERS
  1235.  *  void
  1236.  * RETURNS
  1237.  *  void
  1238.  *****************************************************************************/
  1239. void MMI_key_2_up(void)
  1240. {
  1241.     /*----------------------------------------------------------------*/
  1242.     /* Local Variables                                                */
  1243.     /*----------------------------------------------------------------*/
  1245.     /*----------------------------------------------------------------*/
  1246.     /* Code Body                                                      */
  1247.     /*----------------------------------------------------------------*/
  1248.     MMI_key_input_handler(KEY_2, KEY_EVENT_UP);
  1249. }
  1252. /*****************************************************************************
  1253.  * FUNCTION
  1254.  *  MMI_key_3_up
  1255.  * DESCRIPTION
  1256.  *  Handle key 3 release event
  1257.  * PARAMETERS
  1258.  *  void
  1259.  * RETURNS
  1260.  *  void
  1261.  *****************************************************************************/
  1262. void MMI_key_3_up(void)
  1263. {
  1264.     /*----------------------------------------------------------------*/
  1265.     /* Local Variables                                                */
  1266.     /*----------------------------------------------------------------*/
  1268.     /*----------------------------------------------------------------*/
  1269.     /* Code Body                                                      */
  1270.     /*----------------------------------------------------------------*/
  1271.     MMI_key_input_handler(KEY_3, KEY_EVENT_UP);
  1272. }
  1275. /*****************************************************************************
  1276.  * FUNCTION
  1277.  *  MMI_key_4_up
  1278.  * DESCRIPTION
  1279.  *  Handle key 4 release event
  1280.  * PARAMETERS
  1281.  *  void
  1282.  * RETURNS
  1283.  *  void
  1284.  *****************************************************************************/
  1285. void MMI_key_4_up(void)
  1286. {
  1287.     /*----------------------------------------------------------------*/
  1288.     /* Local Variables                                                */
  1289.     /*----------------------------------------------------------------*/
  1291.     /*----------------------------------------------------------------*/
  1292.     /* Code Body                                                      */
  1293.     /*----------------------------------------------------------------*/
  1294.     MMI_key_input_handler(KEY_4, KEY_EVENT_UP);
  1295. }
  1298. /*****************************************************************************
  1299.  * FUNCTION
  1300.  *  MMI_key_5_up
  1301.  * DESCRIPTION
  1302.  *  Handle key 5 release event
  1303.  * PARAMETERS
  1304.  *  void
  1305.  * RETURNS
  1306.  *  void
  1307.  *****************************************************************************/
  1308. void MMI_key_5_up(void)
  1309. {
  1310.     /*----------------------------------------------------------------*/
  1311.     /* Local Variables                                                */
  1312.     /*----------------------------------------------------------------*/
  1314.     /*----------------------------------------------------------------*/
  1315.     /* Code Body                                                      */
  1316.     /*----------------------------------------------------------------*/
  1317.     MMI_key_input_handler(KEY_5, KEY_EVENT_UP);
  1318. }
  1321. /*****************************************************************************
  1322.  * FUNCTION
  1323.  *  MMI_key_6_up
  1324.  * DESCRIPTION
  1325.  *  Handle key 6 release event
  1326.  * PARAMETERS
  1327.  *  void
  1328.  * RETURNS
  1329.  *  void
  1330.  *****************************************************************************/
  1331. void MMI_key_6_up(void)
  1332. {
  1333.     /*----------------------------------------------------------------*/
  1334.     /* Local Variables                                                */
  1335.     /*----------------------------------------------------------------*/
  1337.     /*----------------------------------------------------------------*/
  1338.     /* Code Body                                                      */
  1339.     /*----------------------------------------------------------------*/
  1340.     MMI_key_input_handler(KEY_6, KEY_EVENT_UP);
  1341. }
  1344. /*****************************************************************************
  1345.  * FUNCTION
  1346.  *  MMI_key_7_up
  1347.  * DESCRIPTION
  1348.  *  Handle key 7 release event
  1349.  * PARAMETERS
  1350.  *  void
  1351.  * RETURNS
  1352.  *  void
  1353.  *****************************************************************************/
  1354. void MMI_key_7_up(void)
  1355. {
  1356.     /*----------------------------------------------------------------*/
  1357.     /* Local Variables                                                */
  1358.     /*----------------------------------------------------------------*/
  1360.     /*----------------------------------------------------------------*/
  1361.     /* Code Body                                                      */
  1362.     /*----------------------------------------------------------------*/
  1363.     MMI_key_input_handler(KEY_7, KEY_EVENT_UP);
  1364. }
  1367. /*****************************************************************************
  1368.  * FUNCTION
  1369.  *  MMI_key_8_up
  1370.  * DESCRIPTION
  1371.  *  Handle key 8 release event
  1372.  * PARAMETERS
  1373.  *  void
  1374.  * RETURNS
  1375.  *  void
  1376.  *****************************************************************************/
  1377. void MMI_key_8_up(void)
  1378. {
  1379.     /*----------------------------------------------------------------*/
  1380.     /* Local Variables                                                */
  1381.     /*----------------------------------------------------------------*/
  1383.     /*----------------------------------------------------------------*/
  1384.     /* Code Body                                                      */
  1385.     /*----------------------------------------------------------------*/
  1386.     MMI_key_input_handler(KEY_8, KEY_EVENT_UP);
  1387. }
  1390. /*****************************************************************************
  1391.  * FUNCTION
  1392.  *  MMI_key_9_up
  1393.  * DESCRIPTION
  1394.  *  Handle key 9 release event
  1395.  * PARAMETERS
  1396.  *  void
  1397.  * RETURNS
  1398.  *  void
  1399.  *****************************************************************************/
  1400. void MMI_key_9_up(void)
  1401. {
  1402.     /*----------------------------------------------------------------*/
  1403.     /* Local Variables                                                */
  1404.     /*----------------------------------------------------------------*/
  1406.     /*----------------------------------------------------------------*/
  1407.     /* Code Body                                                      */
  1408.     /*----------------------------------------------------------------*/
  1409.     MMI_key_input_handler(KEY_9, KEY_EVENT_UP);
  1410. }
  1412. /* multitap for star and pound */
  1415. /*****************************************************************************
  1416.  * FUNCTION
  1417.  *  MMI_key_star_up
  1418.  * DESCRIPTION
  1419.  *  Handle key star release event
  1420.  * PARAMETERS
  1421.  *  void
  1422.  * RETURNS
  1423.  *  void
  1424.  *****************************************************************************/
  1425. void MMI_key_star_up(void)
  1426. {
  1427.     /*----------------------------------------------------------------*/
  1428.     /* Local Variables                                                */
  1429.     /*----------------------------------------------------------------*/
  1431.     /*----------------------------------------------------------------*/
  1432.     /* Code Body                                                      */
  1433.     /*----------------------------------------------------------------*/
  1434.     MMI_key_input_handler(KEY_STAR, KEY_EVENT_UP);
  1435. }
  1438. /*****************************************************************************
  1439.  * FUNCTION
  1440.  *  MMI_key_pound_up
  1441.  * DESCRIPTION
  1442.  *  Handle key pound release event
  1443.  * PARAMETERS
  1444.  *  void
  1445.  * RETURNS
  1446.  *  void
  1447.  *****************************************************************************/
  1448. void MMI_key_pound_up(void)
  1449. {
  1450.     /*----------------------------------------------------------------*/
  1451.     /* Local Variables                                                */
  1452.     /*----------------------------------------------------------------*/
  1454.     /*----------------------------------------------------------------*/
  1455.     /* Code Body                                                      */
  1456.     /*----------------------------------------------------------------*/
  1457.     MMI_key_input_handler(KEY_POUND, KEY_EVENT_UP);
  1458. }
  1461. /*****************************************************************************
  1462.  * FUNCTION
  1463.  *  register_MMI_key_input_extend_handler
  1464.  * DESCRIPTION
  1465.  *  Register key handlers for start and pound key.
  1466.  * PARAMETERS
  1467.  *  void
  1468.  * RETURNS
  1469.  *  void
  1470.  *****************************************************************************/
  1471. void register_MMI_key_input_extend_handler(void)
  1472. {
  1473.     /*----------------------------------------------------------------*/
  1474.     /* Local Variables                                                */
  1475.     /*----------------------------------------------------------------*/
  1477.     /*----------------------------------------------------------------*/
  1478.     /* Code Body                                                      */
  1479.     /*----------------------------------------------------------------*/
  1480.     SetKeyHandler(MMI_key_star_down, KEY_STAR, KEY_EVENT_DOWN);
  1481.     SetKeyHandler(MMI_key_star_up, KEY_STAR, KEY_EVENT_UP);
  1483.     SetKeyHandler(MMI_key_pound_down, KEY_POUND, KEY_EVENT_DOWN);
  1484.     SetKeyHandler(MMI_key_pound_up, KEY_POUND, KEY_EVENT_UP);
  1485. }
  1488. /*****************************************************************************
  1489.  * FUNCTION
  1490.  *  register_MMI_key_input_handler
  1491.  * DESCRIPTION
  1492.  *  Register key handlers for all digit keys
  1493.  * PARAMETERS
  1494.  *  void
  1495.  * RETURNS
  1496.  *  void
  1497.  *****************************************************************************/
  1498. void register_MMI_key_input_handler(void)
  1499. {
  1500.     /*----------------------------------------------------------------*/
  1501.     /* Local Variables                                                */
  1502.     /*----------------------------------------------------------------*/
  1504.     /*----------------------------------------------------------------*/
  1505.     /* Code Body                                                      */
  1506.     /*----------------------------------------------------------------*/
  1507.     SetKeyHandler(MMI_key_0_down, KEY_0, KEY_EVENT_DOWN);
  1508.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_EVENT_DOWN);
  1509.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_EVENT_DOWN);
  1510.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_EVENT_DOWN);
  1511.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_EVENT_DOWN);
  1512.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_EVENT_DOWN);
  1513.     SetKeyHandler(MMI_key_6_down, KEY_6, KEY_EVENT_DOWN);
  1514.     SetKeyHandler(MMI_key_7_down, KEY_7, KEY_EVENT_DOWN);
  1515.     SetKeyHandler(MMI_key_8_down, KEY_8, KEY_EVENT_DOWN);
  1516.     SetKeyHandler(MMI_key_9_down, KEY_9, KEY_EVENT_DOWN);
  1518.     SetKeyHandler(MMI_key_0_down, KEY_0, KEY_REPEAT);
  1519.     SetKeyHandler(MMI_key_1_down, KEY_1, KEY_REPEAT);
  1520.     SetKeyHandler(MMI_key_2_down, KEY_2, KEY_REPEAT);
  1521.     SetKeyHandler(MMI_key_3_down, KEY_3, KEY_REPEAT);
  1522.     SetKeyHandler(MMI_key_4_down, KEY_4, KEY_REPEAT);
  1523.     SetKeyHandler(MMI_key_5_down, KEY_5, KEY_REPEAT);
  1524.     SetKeyHandler(MMI_key_6_down, KEY_6, KEY_REPEAT);
  1525.     SetKeyHandler(MMI_key_7_down, KEY_7, KEY_REPEAT);
  1526.     SetKeyHandler(MMI_key_8_down, KEY_8, KEY_REPEAT);
  1527.     SetKeyHandler(MMI_key_9_down, KEY_9, KEY_REPEAT);
  1529.     SetKeyHandler(MMI_key_0_up, KEY_0, KEY_EVENT_UP);
  1530.     SetKeyHandler(MMI_key_1_up, KEY_1, KEY_EVENT_UP);
  1531.     SetKeyHandler(MMI_key_2_up, KEY_2, KEY_EVENT_UP);
  1532.     SetKeyHandler(MMI_key_3_up, KEY_3, KEY_EVENT_UP);
  1533.     SetKeyHandler(MMI_key_4_up, KEY_4, KEY_EVENT_UP);
  1534.     SetKeyHandler(MMI_key_5_up, KEY_5, KEY_EVENT_UP);
  1535.     SetKeyHandler(MMI_key_6_up, KEY_6, KEY_EVENT_UP);
  1536.     SetKeyHandler(MMI_key_7_up, KEY_7, KEY_EVENT_UP);
  1537.     SetKeyHandler(MMI_key_8_up, KEY_8, KEY_EVENT_UP);
  1538.     SetKeyHandler(MMI_key_9_up, KEY_9, KEY_EVENT_UP);
  1539. }
  1541. /*****************************************************************************
  1542.  * FUNCTION
  1543.  *  clear_MMI_key_input_handler
  1544.  * DESCRIPTION
  1545.  *  Clear key handlers for input
  1546.  * PARAMETERS
  1547.  *  void
  1548.  * RETURNS
  1549.  *  void
  1550.  *****************************************************************************/
  1551. void clear_MMI_key_input_handler(void)
  1552. {
  1553.     /*----------------------------------------------------------------*/
  1554.     /* Local Variables                                                */
  1555.     /*----------------------------------------------------------------*/
  1557.     /*----------------------------------------------------------------*/
  1558.     /* Code Body                                                      */
  1559.     /*----------------------------------------------------------------*/
  1560.     ClearKeyHandler(KEY_0, KEY_EVENT_DOWN);
  1561.     ClearKeyHandler(KEY_1, KEY_EVENT_DOWN);
  1562.     ClearKeyHandler(KEY_2, KEY_EVENT_DOWN);
  1563.     ClearKeyHandler(KEY_3, KEY_EVENT_DOWN);
  1564.     ClearKeyHandler(KEY_4, KEY_EVENT_DOWN);
  1565.     ClearKeyHandler(KEY_5, KEY_EVENT_DOWN);
  1566.     ClearKeyHandler(KEY_6, KEY_EVENT_DOWN);
  1567.     ClearKeyHandler(KEY_7, KEY_EVENT_DOWN);
  1568.     ClearKeyHandler(KEY_8, KEY_EVENT_DOWN);
  1569.     ClearKeyHandler(KEY_9, KEY_EVENT_DOWN);
  1571.     ClearKeyHandler(KEY_0, KEY_EVENT_UP);
  1572.     ClearKeyHandler(KEY_1, KEY_EVENT_UP);
  1573.     ClearKeyHandler(KEY_2, KEY_EVENT_UP);
  1574.     ClearKeyHandler(KEY_3, KEY_EVENT_UP);
  1575.     ClearKeyHandler(KEY_4, KEY_EVENT_UP);
  1576.     ClearKeyHandler(KEY_5, KEY_EVENT_UP);
  1577.     ClearKeyHandler(KEY_6, KEY_EVENT_UP);
  1578.     ClearKeyHandler(KEY_7, KEY_EVENT_UP);
  1579.     ClearKeyHandler(KEY_8, KEY_EVENT_UP);
  1580.     ClearKeyHandler(KEY_9, KEY_EVENT_UP);
  1582. #if defined(__MMI_MULTITAP_FOR_STAR_AND_POUND__)
  1583.     ClearKeyHandler(KEY_POUND, KEY_EVENT_DOWN);
  1584.     ClearKeyHandler(KEY_POUND, KEY_EVENT_UP);
  1586.     ClearKeyHandler(KEY_STAR, KEY_EVENT_DOWN);
  1587.     ClearKeyHandler(KEY_STAR, KEY_EVENT_UP);
  1588. #endif
  1590. }
  1592. /* Initialization / termination wrappers  */
  1595. /*****************************************************************************
  1596.  * FUNCTION
  1597.  *  wgui_init
  1598.  * DESCRIPTION
  1599.  *  Initializes the GUI wrappers
  1600.  * PARAMETERS
  1601.  *  void
  1602.  * RETURNS
  1603.  *  void
  1604.  *****************************************************************************/
  1605. void wgui_init(void)
  1606. {
  1607.     /*----------------------------------------------------------------*/
  1608.     /* Local Variables                                                */
  1609.     /*----------------------------------------------------------------*/
  1611.     /*----------------------------------------------------------------*/
  1612.     /* Code Body                                                      */
  1613.     /*----------------------------------------------------------------*/
  1614.     
  1615. #ifdef __MMI_FREETYPE_SETTING_SUPPORT__
  1616.     gui_freetype_set_size(PhnsetGetFreeTypeSetting());
  1617. #endif
  1619.     set_MMI_theme((MMI_theme*) MMI_themes[0]);
  1621.     gui_initialize_default_themes();
  1623. #if(!UI_DISABLE_EMS_INPUT_BOX)
  1624.     gui_intialize_EMS();
  1625. #endif 
  1627.     register_keyboard_key_handler(dummy_keyboard_key_handler);
  1628.     register_keyboard_input_handler(dummy_keyboard_input_handler);
  1629.     register_keyboard_global_key_handler(dummy_keyboard_key_handler);
  1631.     create_softkeys();
  1632.     create_menu_shortcut_handler();
  1633.     create_fixed_list();
  1634.     create_fixed_matrix();
  1635.     
  1636. #if defined(__MMI_VIRTUAL_KEYBOARD__)
  1637.     create_virtual_keyboard();
  1638. #endif /* defined(__MMI_VIRTUAL_KEYBOARD__) */
  1640.     clear_key_input_handler();
  1641.     clear_key_down_handler();
  1642.     clear_key_up_handler();
  1643.     initialize_status_icons();
  1644.     register_multiline_inputbox_input_callback(UI_dummy_function);
  1645. }
  1647. extern void UpdateUITheme(void);
  1649. /** Animation handle of title icon */
  1650. GDI_HANDLE MMI_title_icon_ani_handle = GDI_ERROR_HANDLE;
  1652. extern FuncPtr gExitFullScreenCallBack;
  1654. /*****************************************************************************
  1655.  * FUNCTION
  1656.  *  UI_common_screen_pre_exit
  1657.  * DESCRIPTION
  1658.  *  Failsafe screen exit function *before* screen exit function
  1659.  * PARAMETERS
  1660.  *  void
  1661.  * RETURNS
  1662.  *  void
  1663.  * REMARKS
  1664.  *  Some functions should not be invoked after screen exit function.
  1665.  *  (e.g. BLT on layers that are already released.)
  1666.  *****************************************************************************/
  1667. void UI_common_screen_pre_exit(void)
  1668. {
  1669.     /*----------------------------------------------------------------*/
  1670.     /* Local Variables                                                */
  1671.     /*----------------------------------------------------------------*/
  1673.     /*----------------------------------------------------------------*/
  1674.     /* Code Body                                                      */
  1675.     /*----------------------------------------------------------------*/
  1676.     /* suspend VRT as soon as possible when screen is exited */
  1677. #ifdef __MMI_VUI_ENGINE__
  1678.     vrt_canvas_suspend();
  1679. #endif    
  1680.     
  1681. #ifdef __MMI_TOUCH_SCREEN__
  1682.     mmi_pen_reset();
  1683. #endif 
  1684.     gui_pre_cleanup();
  1685.     if (!dm_is_activated())
  1686.     {
  1687.         dm_reset_context_ext();
  1688.     }
  1690. #ifdef __MMI_SCREEN_SWITCH_EFFECT__
  1691.     gui_screen_switch_effect_pre_exit_screen();
  1692. #endif    
  1693. }
  1696. /*****************************************************************************
  1697.  * FUNCTION
  1698.  *  UI_common_component_exit
  1699.  * DESCRIPTION
  1700.  *  Failsafe screen exit function *after* screen exit function
  1701.  * PARAMETERS
  1702.  *  void
  1703.  * RETURNS
  1704.  *  void
  1705.  *****************************************************************************/
  1706. void UI_common_component_exit(void)
  1708. {
  1709.     /*----------------------------------------------------------------*/
  1710.     /* Local Variables                                                */
  1711.     /*----------------------------------------------------------------*/
  1713.     /*----------------------------------------------------------------*/
  1714.     /* Code Body                                                      */
  1715.     /*----------------------------------------------------------------*/
  1716.     wgui_title_close();
  1717.     wgui_title_create();
  1718.     wgui_title_set_no_icon_shct(MMI_FALSE);
  1719.     wgui_title_set_thick(MMI_FALSE);
  1720.     hide_status_icon_bar(0);
  1721.     hide_status_icon_bar(1);
  1722.     register_hide_status_icon_bar(0, hide_status_icons_bar0);
  1723.     wgui_status_icon_reset_alpha_layer();
  1724.     wgui_status_icon_reset_all_status_icon_bar_layer();
  1725. #ifdef MMI_SHOW_STATUS_ICON_IN_TITLE 
  1726.     wgui_status_icon_integrated_enable(MMI_TRUE);
  1727.     wgui_status_icon_integrated_register_redraw(NULL);
  1728. #endif
  1729.     clear_category_screen_key_handlers();
  1730.     clear_left_softkey();
  1731.     clear_right_softkey();
  1732. #ifdef __MMI_WGUI_CSK_ENABLE__
  1733.     clear_softkey_display_functions(MMI_CENTER_SOFTKEY);
  1734.     ResetCenterSoftkey();
  1735. #endif
  1737.     /* Editor common exit handler */
  1738.     wgui_inputs_close();
  1740.     /* for some special screen do not resize list */
  1741.     resize_fixed_list(MMI_content_width, MMI_content_height);
  1743.     /* Reset the toggle transition effect when exit screen */
  1744. #ifdef __MMI_UI_HINT_TOGGLE_TRANSITION__
  1745.     wgui_reset_pop_up_description_transition();
  1746. #endif
  1747. }
  1748. /*****************************************************************************
  1749.  * FUNCTION
  1750.  *  UI_common_screen_exit
  1751.  * DESCRIPTION
  1752.  *  Failsafe screen exit function *after* screen exit function
  1753.  * PARAMETERS
  1754.  *  void
  1755.  * RETURNS
  1756.  *  void
  1757.  *****************************************************************************/
  1758. void UI_common_screen_exit(void)
  1759. {
  1760.     /*----------------------------------------------------------------*/
  1761.     /* Local Variables                                                */
  1762.     /*----------------------------------------------------------------*/
  1763.     gdi_handle main_base_layer;
  1765.     /*----------------------------------------------------------------*/
  1766.     /* Code Body                                                      */
  1767.     /*----------------------------------------------------------------*/      
  1768.     /* de-initialize gui effect */
  1769. #ifdef __MMI_UI_EFFECT_ENGINE__
  1770.     gui_effect_close();
  1771. #endif
  1773. #ifdef __MMI_SCREEN_SWITCH_EFFECT__
  1774.     gui_screen_switch_effect_pre_exit_category();
  1775. #endif
  1776.     
  1777. #ifdef __MMI_VIRTUAL_KEYBOARD__
  1778.     wgui_close_virtual_keyboard();
  1779. #endif
  1781.     if (ExitCategoryFunction != NULL)
  1782.     {
  1783.         ExitCategoryFunction();
  1784.     }
  1786. #if defined(__MMI_SCREEN_SWITCH_EFFECT__) || defined(GUI_LIST_MENU_SMOOTH_SCROLLING_BY_KEY) || defined(GUI_LIST_MENU_SMOOTH_SCROLLING_BY_PEN)
  1787.     gui_screen_switch_effect_post_exit_category();
  1788. #endif
  1789.     
  1790.     /* set default ABM source layer to the main base layer */
  1791.     gdi_layer_get_base_handle(&main_base_layer);
  1792.     gdi_set_alpha_blending_source_layer(main_base_layer);    
  1793.     
  1794. #ifdef __MMI_TOUCH_SCREEN__
  1795.     wgui_register_general_pen_handler();
  1796.     wgui_reset_list_item_selected_callback();
  1797.     wgui_reset_matrix_item_selected_callback();
  1798. #endif /* __MMI_TOUCH_SCREEN__ */ 
  1800. mmi_imc_exit_screen();
  1802.     gui_cleanup();
  1804.     ClearHighlightHandler();
  1806.     gui_hide_animations();
  1807.     animation_handle = GDI_ERROR_HANDLE;
  1808.     if (MMI_title_icon_ani_handle != GDI_ERROR_HANDLE)
  1809.     {
  1810.         gdi_image_stop_animation(MMI_title_icon_ani_handle);
  1811.         MMI_title_icon_ani_handle = GDI_ERROR_HANDLE;
  1812.     }
  1813.     StopTimer(BLINKING_CURSOR);
  1814. #ifdef __MMI_THEMES_APPLICATION__
  1815. #ifndef __MMI_DOWNLOADABLE_THEMES_SUPPORT__
  1816.     UpdateUITheme();
  1817. #endif 
  1818. #endif /* __MMI_THEMES_APPLICATION__ */ 
  1819.     ExitCategoryFunction = MMI_dummy_function;
  1820.     RedrawCategoryFunction = MMI_dummy_function;
  1821.     GetCategoryHistory = dummy_get_history;
  1822.     GetCategoryHistorySize = dummy_get_history_size;
  1824. #ifdef __MMI_UI_LIST_HIGHLIGHT_EFFECTS__
  1825.     gui_unblock_list_effect();
  1826. #endif /* __MMI_UI_LIST_HIGHLIGHT_EFFECTS__ */  
  1828.     /* set multilayer mask on/off */
  1829. #if defined (__GDI_MEMORY_PROFILE_2__)
  1830.     {
  1831.     #if defined(__MMI_SUBMENU_USE_MM_IMAGE__)
  1832.         gui_set_multilayer_mask(gui_get_multilayer_mask() | UI_MUL_BKG_MAINMENU | UI_MUL_BKG_SUBMENU);
  1833.         if (mmi_bootup_is_searching_or_idle_reached() == MMI_FALSE)
  1834.         {
  1835.             gui_set_multilayer_mask(gui_get_multilayer_mask() & (~UI_MUL_BKG_SUBMENU));
  1836.         }
  1837.         else
  1838.         {
  1839.             gui_set_multilayer_mask(gui_get_multilayer_mask() | UI_MUL_BKG_SUBMENU);
  1840.         }
  1841.     #else 
  1842.         gui_set_multilayer_mask(gui_get_multilayer_mask() & (~UI_MUL_BKG_MAINMENU) & (~UI_MUL_BKG_SUBMENU));
  1843.     #endif 
  1844.     }
  1845. #endif /* defined (__GDI_MEMORY_PROFILE_2__) */ 
  1847.     /* free all layer to be base layer */
  1848.     gui_free_multilayer_screen();
  1849.     gui_set_entry_new_screen(MMI_TRUE);
  1850.     /* redraw status */
  1851.     if (wgui_is_wallpaper_on_bottom())
  1852.     {
  1853.         gOnFullScreen = MMI_LEAVE_BG_ON_BOTTOM_SCREEN;
  1854.         wgui_reset_wallpaper_on_bottom();   /* support wallpaper on bottom */
  1855.     }
  1856.     gdi_image_gif_reset();
  1857.     gui_reset_clip();
  1858.     gui_reset_text_clip();
  1859.     reset_softkeys();
  1860.     
  1861. #if defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) || defined (__MMI_MAINLCD_240X400__) || defined (__MMI_MAINLCD_320X240__)
  1862.     if (gExitFullScreenCallBack != NULL)
  1863.     {
  1864.         gExitFullScreenCallBack();
  1865.         gExitFullScreenCallBack = NULL;
  1866.     }
  1867. #endif /* defined(__MMI_MAINLCD_176X220__) || defined (__MMI_MAINLCD_240X320__) || defined (__MMI_MAINLCD_240X400__) || defined (__MMI_MAINLCD_320X240__) */    
  1869. #ifdef __MMI_SCREEN_ROTATE__
  1870.     mmi_frm_reset_screen_rotation();
  1871. #endif 
  1873.     UI_common_component_exit();
  1875.     gui_setup_default_layout();
  1877. #ifndef __MTK_TARGET__    
  1878.     /* 
  1879.      * Notify MTE there is a screen switch.
  1880.      *
  1881.      * Actually, this is quite tricky. But to get the current screen refreshed for 
  1882.      * full screen applications, such as JAVA, WAP, camera, ... , and etc,
  1883.      * this is necessary.
  1884.      */
  1885.     mmi_mte_mmi_notify_new_screen();
  1886. #endif /* __MTK_TARGET__ */
  1888.     MMI_ASSERT(mmi_frm_scrmem_is_all_free());
  1889. }   /* end of UI_common_screen_exit */