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

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

MTK

开发平台：

C/C++

Events.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.  * Events.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *   MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *   This file is intends for protocol/keypad/interrupt event handler .
  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.  *
  59.  * removed!
  60.  * removed!
  61.  * removed!
  62.  *
  63.  * removed!
  64.  * removed!
  65.  * removed!
  66.  *
  67.  * removed!
  68.  * removed!
  69.  * removed!
  70.  *
  71.  * removed!
  72.  * removed!
  73.  * removed!
  74.  *
  75.  * removed!
  76.  * removed!
  77.  * removed!
  78.  *
  79.  * removed!
  80.  * removed!
  81.  * removed!
  82.  *
  83.  * removed!
  84.  * removed!
  85.  * removed!
  86.  *
  87.  * removed!
  88.  * removed!
  89.  * removed!
  90.  * removed!
  91.  *
  92.  * removed!
  93.  * removed!
  94.  * removed!
  95.  *
  96.  * removed!
  97.  * removed!
  98.  * removed!
  99.  *
  100.  * removed!
  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.  * removed!
  137.  * removed!
  138.  *
  139.  * removed!
  140.  * removed!
  141.  * removed!
  142.  *
  143.  * removed!
  144.  * removed!
  145.  * removed!
  146.  *
  147.  * removed!
  148.  * removed!
  149.  * removed!
  150.  *
  151.  * removed!
  152.  * removed!
  153.  * removed!
  154.  *
  155.  * removed!
  156.  * removed!
  157.  * removed!
  158.  *
  159.  * removed!
  160.  * removed!
  161.  * removed!
  162.  *
  163.  * removed!
  164.  * removed!
  165.  * removed!
  166.  *
  167.  * removed!
  168.  * removed!
  169.  * removed!
  170.  *
  171.  * removed!
  172.  * removed!
  173.  * removed!
  174.  *
  175.  * removed!
  176.  * removed!
  177.  * removed!
  178.  *
  179.  * removed!
  180.  * removed!
  181.  * removed!
  182.  *
  183.  * removed!
  184.  * removed!
  185.  * removed!
  186.  *
  187.  * removed!
  188.  * removed!
  189.  * removed!
  190.  *
  191.  * removed!
  192.  * removed!
  193.  * removed!
  194.  *
  195.  * removed!
  196.  * removed!
  197.  * removed!
  198.  *
  199.  * removed!
  200.  * removed!
  201.  * removed!
  202.  * removed!
  203.  * removed!
  204.  * removed!
  205.  * removed!
  206.  * removed!
  207.  * removed!
  208.  * removed!
  209.  * removed!
  210.  * removed!
  211.  * removed!
  212.  * removed!
  213.  * removed!
  214.  * removed!
  215.  * removed!
  216.  * removed!
  217.  * removed!
  218.  * removed!
  219.  * removed!
  220.  *
  221.  * removed!
  222.  * removed!
  223.  * removed!
  224.  *
  225.  * removed!
  226.  * removed!
  227.  * removed!
  228.  *
  229.  * removed!
  230.  * removed!
  231.  * removed!
  232.  *
  233.  * removed!
  234.  * removed!
  235.  * removed!
  236.  *
  237.  * removed!
  238.  * removed!
  239.  * removed!
  240.  *
  241.  * removed!
  242.  * removed!
  243.  * removed!
  244.  *
  245.  * removed!
  246.  * removed!
  247.  * removed!
  248.  *
  249.  * removed!
  250.  * removed!
  251.  * removed!
  252.  *
  253.  * removed!
  254.  * removed!
  255.  * removed!
  256.  *
  257.  * removed!
  258.  * removed!
  259.  * removed!
  260.  *
  261.  * removed!
  262.  * removed!
  263.  * removed!
  264.  *
  265.  * removed!
  266.  * removed!
  267.  * removed!
  268.  *
  269.  * removed!
  270.  * removed!
  271.  * removed!
  272.  *
  273.  * removed!
  274.  * removed!
  275.  * removed!
  276.  *
  277.  * removed!
  278.  * removed!
  279.  * removed!
  280.  *
  281.  * removed!
  282.  * removed!
  283.  * removed!
  284.  *
  285.  *------------------------------------------------------------------------------
  286.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  287.  *==============================================================================
  288.  *******************************************************************************/
  290. #include "MMI_features.h"
  291. #include "stdC.h"
  292. #include "L4Dr1.h"
  293. #include "GlobalConstants.h"
  294. #include "DebugInitDef.h"
  295. #include "PixtelDataTypes.h"
  296. #include "ProtocolEvents.h"
  297. #include "FrameworkStruct.h"
  298. #include "EventsGprot.h"
  299. #include "WrapperGprot.h"
  300. #include "KeyBrd.h"
  301. #include "EventsDcl.h"
  302. #include "EventsDef.h"
  303. #include "CustDataProts.h"
  304. #include "SATGProts.h"
  305. #include "IdleAppProt.h"
  306. #include "IdleAppDef.h"
  307. #include "SubLCDHistoryGprot.h"
  308. #include "SimDetectionGexdcl.h"
  309. #include "SimDetectionGprot.h"
  310. #include "SettingDefs.h"
  311. #include "SettingsGdcl.h"
  312. #include "CallManagementGprot.h"
  313. #ifdef __MMI_VOIP__
  314. #include "VoIPGProt.h"
  315. #endif
  316. #include "VolumeHandler.h"
  317. #ifdef __MMI_TOUCH_SCREEN__
  318. #include "wgui_touch_screen.h"
  319. #endif 
  320. #ifdef __MMI_DOWNLOADABLE_THEMES_SUPPORT__
  321. #include "ThemeManager.h"
  322. #endif 
  324. #include "l4dr.h"
  325. #include "MMI_trc.h"
  326. #include "QuickAccessMenuItem_def.h"
  327. #ifdef __MMI_WGUI_MINI_TAB_BAR__
  328. #include "wgui_tab_bars.h"
  329. #endif 
  330. /* added by MK */
  331. #ifdef __MMI_EMAIL__
  332. #include "EmailAppGProt.h"
  333. #endif // #ifdef __MMI_EMAIL__
  334. #include "KeyBrd.h"
  337. #if defined(__MMI_RESOURCE_ENFB_SUPPORT__)
  338. #include "ResMemMgrGprot.h"
  339. #endif /* __MMI_RESOURCE_ENFB_SUPPORT__ */
  341. /*
  342.  * Define
  343.  */
  344. #define INTERRUPT_EVENT_GREOUP_SIZE     (4)
  345. #define IS_INTERRUPT_EVENT_GROUP(x)    (((x)&MMI_INT_EVENT_GROUP_MASK) == MMI_INT_EVENT_GROUP_MASK)
  347. /* for profiling */
  348. #if 0
  349. /* under construction !*/
  350. #endif
  352. #define MMI_EVENT_INVALID  0
  354. /*
  355.  * Data Type
  356.  */
  357. typedef struct
  358. {
  359.     U16 groupID;
  360.     U16 eventID[INTERRUPT_EVENT_GREOUP_SIZE];
  361. } InterruptGroupInfo;
  363. /* 
  364.  *   Extern Varibales 
  365.  */
  366. extern pBOOL IsBackHistory;
  367. extern U8 gIsHelpEnabled;
  368. extern U8 gInitAllAppFlag;
  369. extern U8 gInsertSimAppFlag;
  370. extern U8 gEmerencyNoDialed;
  371. extern U8 gIsInSATCall;
  373. FuncPtr currKeyFuncPtrs[MAX_KEYS][MAX_KEY_TYPE];    /* available key func ptrs to current screen  */
  374. hiliteInfo maxHiliteInfo[MAX_HILITE_HANDLER];       /* available hilite func ptrs  */
  375. U8 hintData[MAX_SUB_MENUS][MAX_SUB_MENU_HINT_SIZE];
  376. U8 subMenuData[MAX_SUB_MENUS][MAX_SUB_MENU_SIZE];
  377. PU8 subMenuDataPtrs[MAX_SUB_MENUS];
  378. PU8 hintDataPtrs[MAX_SUB_MENUS];
  379. U8 processUpRepeatKey = 0;
  380. U8 pressKey = 0;                                    /* 0- full up, 1- half down, 2- full down */
  382. /* 
  383.  *   Local Variables 
  384.  */
  386. /*
  387.  * If we add new interrupt event group id
  388.  * , we fill the table to establish the mapping events table.
  389.  */
  390. static InterruptGroupInfo interruptGroupEventTable[] = 
  391. {
  392.     {MMI_SMS_INT_EVENT_GROUP,
  393.      {PRT_MSG_ID_MMI_SMS_DELIVER_MSG_IND,
  394.       PRT_MSG_ID_MMI_SMS_STATUS_REPORT_IND,
  395.       PRT_MSG_ID_MMI_SMS_MSG_WAITING_IND,
  396.       0 /* end at 0 */
  397.       }
  398.      }
  399. #if defined(__MMI_FILE_MANAGER__)
  400.     ,{MMI_CARD_PLUG_EVENT_GROUP,
  401.      {MSG_ID_FMT_MMI_CARD_PLUG_IN_IND,
  402.       MSG_ID_FMT_MMI_CARD_PLUG_OUT_IND,
  403.       0 /* end at 0 */
  404.       }
  405.      }
  406. #endif /* __MMI_FILE_MANAGER__ */
  407. };
  409. static U16 currMaxHiliteInfo;               /* currently max hilite info */
  410. static U16 maxProtocolEvent;
  411. static U16 usedProtocolEvent;
  412. static U16 maxInterruptEvent;
  413. static U16 currParentID;                    /* current parent item id */
  414. static U16 currKeyCode;
  415. static U16 currKeyType;
  416. static U16 currHiliteID;
  417. static FuncPtr currEntryFuncPtr;
  418. static U16 currExitScrnID, currTopScrnID;   /* curr exit func ptr with scrn id */
  419. static FuncPtr currExitFuncPtr;
  420. static PseventInfo protocolEventHandler[MAX_PROTOCOL_EVENT];
  421. static PsInteventInfo interruptEventHandler[MAX_INTERRUPT_EVENT];
  422. static MMI_BOOL mmu_frm_execute_scrn_exit_handler = MMI_FALSE;
  424. /* 
  425.  *   Local Functions 
  426.  */
  427. static void ExecuteCurrExitHandler(void);       /* execute current exit func handler, before execute current event handler */
  428. static void ExecuteCurrExitHandler_Ext(void);   /* execute current exit func handler, before execute current event handler */
  429. static void SetGenericExitHandler(U16 scrnID, FuncPtr exitFuncPtr, FuncPtr entryFuncPtr);
  430. static MMI_BOOL QueryInterruptHandler(U16 eventID, PsIntFuncPtr *funcPtr, PsIntFuncPtr *postfuncPtr);
  432. /* 090404 MTK Calvin removed */
  433. /* static void SetExitHandler(U16 scrnID, FuncPtr exitFuncPtr); */
  434. /* 090404 MTK Calvin end */
  436. /* 
  437.  *   Global Functions 
  438.  */
  439. extern void EmergencyCallCheck(S16 keyCode, S16 keyType);
  440. extern void InitKeypadBeforePWRON(void);
  441. extern U16 GetTotalCallCount(void);
  443. #ifdef __MMI_SCREEN_SNAPSHOT__
  444. extern void mmi_camera_scr_snapshot(void);
  445. #endif 
  448. /*****************************************************************************
  449.  * FUNCTION
  450.  *  InitEvents
  451.  * DESCRIPTION
  452.  *  Initialization
  453.  *  
  454.  *  This is used to Initialize event handlers
  455.  * PARAMETERS
  456.  *  void
  457.  * RETURNS
  458.  *  void
  459.  *****************************************************************************/
  460. void InitEvents(void)
  461. {
  462.     /*----------------------------------------------------------------*/
  463.     /* Local Variables                                                */
  464.     /*----------------------------------------------------------------*/
  465.     U16 keyCode = 0;
  466.     U16 keyType = 0;
  467.     U16 count = 0;
  469.     /*----------------------------------------------------------------*/
  470.     /* Code Body                                                      */
  471.     /*----------------------------------------------------------------*/
  472.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_FUN_EVENT_INIT));
  474.     for (keyCode = 0; keyCode < MAX_KEYS; keyCode++)
  475.     {
  476.         for (keyType = 0; keyType < MAX_KEY_TYPE; keyType++)
  477.         {
  478.             currKeyFuncPtrs[keyCode][keyType] = NULL;
  479.         }
  480.     }
  482.     currEntryFuncPtr = NULL;
  484.     currExitScrnID = 0;
  485.     currTopScrnID = 0;
  486.     currExitFuncPtr = NULL;
  488. mmu_frm_execute_scrn_exit_handler = MMI_FALSE;
  490.     /* JL remove to outside init InitHistory(); */
  492.     currMaxHiliteInfo = 0;
  493.     currParentID = 0;
  495.     maxProtocolEvent = 0;
  496.     usedProtocolEvent = 0;
  498.     /* MTK added by JL for PS interrupt */
  499.     maxInterruptEvent = 0;
  501.     /* //////// initilaize the timer, protocol & hardware events with func ptrs /////// */
  502.     for (count = 0; count < MAX_PROTOCOL_EVENT; count++)
  503.     {
  504.         protocolEventHandler[count].eventID = 0;
  505.         protocolEventHandler[count].entryFuncPtr = NULL;
  506.     }
  508.     for (count = 0; count < MAX_HILITE_HANDLER; count++)
  509.     {
  510.         maxHiliteInfo[count].entryFuncPtr = NULL;
  511.         maxHiliteInfo[count].hintFuncPtr = NULL;
  512.     }
  513.     for (count = 0; count < MAX_SUB_MENUS; count++)
  514.     {
  515.         subMenuDataPtrs[count] = subMenuData[count];
  516.     }
  518.     /* MTK added by JL for PS interrupt */
  519.     for (count = 0; count < MAX_INTERRUPT_EVENT; count++)
  520.     {
  521.         interruptEventHandler[count].eventID = (U16) NULL;
  522.         interruptEventHandler[count].entryIntFuncPtr = NULL;
  523.         interruptEventHandler[count].postIntFuncPtr = NULL;
  524.     }
  526.     /* ////////////////////////////////////////////////////////////////////////////////////// */
  527. }
  530. /*****************************************************************************
  531.  * FUNCTION
  532.  *  DeInitFramework_KeyAndEventHandler
  533.  * DESCRIPTION
  534.  *  DeInitialization
  535.  *  
  536.  *  Deinitialize key and event handlers
  537.  * PARAMETERS
  538.  *  void
  539.  * RETURNS
  540.  *  void
  541.  *****************************************************************************/
  542. void DeInitFramework_KeyAndEventHandler(void)
  543. {
  544.     /*----------------------------------------------------------------*/
  545.     /* Local Variables                                                */
  546.     /*----------------------------------------------------------------*/
  547.     U16 keyCode = 0;
  548.     U16 keyType = 0;
  549.     U16 count = 0;
  551.     /*----------------------------------------------------------------*/
  552.     /* Code Body                                                      */
  553.     /*----------------------------------------------------------------*/
  554.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_FUN_EVENT_DEINIT_KEY_EVENT));
  556.     for (keyCode = 0; keyCode < MAX_KEYS; keyCode++)
  557.     {
  558.         for (keyType = 0; keyType < MAX_KEY_TYPE; keyType++)
  559.         {
  560.             currKeyFuncPtrs[keyCode][keyType] = NULL;
  561.         }
  562.     }
  564.     currEntryFuncPtr = NULL;
  566.     currExitScrnID = 0;
  567.     currTopScrnID = 0;
  568.     currExitFuncPtr = NULL;
  570.     currMaxHiliteInfo = 0;
  571.     currParentID = 0;
  573.     maxProtocolEvent = 0;
  574.     usedProtocolEvent = 0;
  576.     /* //////// initilaize the timer, protocol & hardware events with func ptrs /////// */
  577.     for (count = 0; count < MAX_PROTOCOL_EVENT; count++)
  578.     {
  579.         protocolEventHandler[count].eventID = 0;
  580.         protocolEventHandler[count].entryFuncPtr = NULL;
  581.     }
  583.     for (count = 0; count < MAX_HILITE_HANDLER; count++)
  584.     {
  585.         maxHiliteInfo[count].entryFuncPtr = NULL;
  586.         maxHiliteInfo[count].hintFuncPtr = NULL;
  587.     }
  589. }
  592. /*****************************************************************************
  593.  * FUNCTION
  594.  *  DeInitFramework_History
  595.  * DESCRIPTION
  596.  *  DeInitialization
  597.  *  
  598.  *  Deinitialize History
  599.  * PARAMETERS
  600.  *  void
  601.  * RETURNS
  602.  *  void
  603.  *****************************************************************************/
  604. void DeInitFramework_History(void)
  605. {
  606.     /*----------------------------------------------------------------*/
  607.     /* Local Variables                                                */
  608.     /*----------------------------------------------------------------*/
  610.     /*----------------------------------------------------------------*/
  611.     /* Code Body                                                      */
  612.     /*----------------------------------------------------------------*/
  613.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_FUN_EVENT_DEINIT_HISTORY));
  615. #ifndef MMI_ON_WIN32
  617.     /* to handle key events before finish power off */
  618.     InitKeypadBeforePWRON();
  619. #endif /* MMI_ON_WIN32 */ 
  621.     DinitHistory();
  622.     DinitSubLCDHistory();
  623. }
  626. /*****************************************************************************
  627.  * FUNCTION
  628.  *  DeInitFramework
  629.  * DESCRIPTION
  630.  *  DeInitialization
  631.  *  
  632.  *  This is used to De-initialize history & event handlers
  633.  * PARAMETERS
  634.  *  void
  635.  * RETURNS
  636.  *  void
  637.  *****************************************************************************/
  638. void DeInitFramework(void)
  639. {
  640.     /*----------------------------------------------------------------*/
  641.     /* Local Variables                                                */
  642.     /*----------------------------------------------------------------*/
  644.     /*----------------------------------------------------------------*/
  645.     /* Code Body                                                      */
  646.     /*----------------------------------------------------------------*/
  647.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_FUN_EVENT_DEINIT));
  649.     DeInitFramework_KeyAndEventHandler();
  650.     DeInitFramework_History();
  651. }
  654. /*****************************************************************************
  655.  * FUNCTION
  656.  *  mmi_frm_reset_internal_key_contex
  657.  * DESCRIPTION
  658.  *  Reset internal key contex
  659.  *  
  660.  *  This is used to De-initialize history & event handlers
  661.  * PARAMETERS
  662.  *  void
  663.  * RETURNS
  664.  *  void
  665.  *****************************************************************************/
  666. void mmi_frm_reset_internal_key_contex()
  667. {
  668.     /*----------------------------------------------------------------*/
  669.     /* Local Variables                                                */
  670.     /*----------------------------------------------------------------*/
  672.     /*----------------------------------------------------------------*/
  673.     /* Code Body                                                      */
  674.     /*----------------------------------------------------------------*/
  675.     pressKey = 0;
  676.     processUpRepeatKey = 0;
  677. }
  680. /*****************************************************************************
  681.  * FUNCTION
  682.  *  ExecuteCurrKeyHandler
  683.  * DESCRIPTION
  684.  *  executes current key func handler
  685.  *  
  686.  *  This is used to executes current key func handler
  687.  * PARAMETERS
  688.  *  keyCode     [IN]        
  689.  *  keyType     [IN]        
  690.  * RETURNS
  691.  *  void
  692.  *****************************************************************************/
  693. void ExecuteCurrKeyHandler(S16 keyCode, S16 keyType)
  694. {
  695.     /*----------------------------------------------------------------*/
  696.     /* Local Variables                                                */
  697.     /*----------------------------------------------------------------*/
  698.     FuncPtr currFuncPtr = NULL;
  700.     /*----------------------------------------------------------------*/
  701.     /* Code Body                                                      */
  702.     /*----------------------------------------------------------------*/
  703.     mmi_idle_restart_keypad_lock_timer();   /* 2006/01/16 Restart keypad lock timer if any key is pressed in idle screen */
  705.     currKeyCode = keyCode;
  706.     currKeyType = keyType;
  708.     /* Added for Help */
  709.     /*
  710.      * if(gIsHelpEnabled != 0)
  711.      * {
  712.      * StopTimer(HELP_APPLICATION_TIMER);
  713.      * StartTimer(HELP_APPLICATION_TIMER,HELP_APPLICATION_TIMEOUT,ShowHelp);
  714.      * }
  715.      */
  716.     if (!gEmerencyNoDialed)
  717.     {
  718.         if (mmi_kbd_get_concurrent_mode() == MMI_FALSE)
  719.         {
  720.             /* special handling for single-key mode */
  721.             switch (keyType)
  722.             {
  723.                 case KEY_HALF_PRESS_DOWN:
  724.                     pressKey = 1;   /* 0- full up, 1- half down, 2- full down */
  725.                     break;
  726.                 case KEY_EVENT_DOWN:
  727.                     /* 
  728.                      * The application may call ExecuteCurrKeyHandler() directly 
  729.                      * MMI framework use KEY_HALF_PRESS_DOWN or KEY_FULL_PRESS_DOWN only
  730.                      */
  731.                     pressKey = 2;   /* 0- full up, 1- half down, 2- full down */
  732.                     processUpRepeatKey = 1;
  733.                     break;
  734.                 case KEY_REPEAT:
  735.                     if (!processUpRepeatKey)
  736.                     {
  737.                         return;
  738.                     }
  739.                     break;
  740.                 case KEY_EVENT_UP:
  741.                     if (pressKey == 0)
  742.                     {
  743.                         /* processUpRepeatKey=0; */
  744.                         mmi_frm_reset_internal_key_contex();
  745.                         return;
  746.                     }
  747.                     break;
  748.             }
  749.         }
  751.         currFuncPtr = currKeyFuncPtrs[keyCode][keyType];
  753.         /* MTK Leo add, if there is no handler for center key(KEY_ENTER) registered by APP, use LSK function. */
  754.         if (keyCode == KEY_ENTER && currFuncPtr == NULL)
  755.         {
  756.             /* If any one type of the key eventis registered by APP, we assume APP want to control this key by itself. */
  757.             if (currKeyFuncPtrs[KEY_ENTER][KEY_EVENT_UP] == NULL &&
  758.                 currKeyFuncPtrs[KEY_ENTER][KEY_EVENT_DOWN] == NULL &&
  759.                 currKeyFuncPtrs[KEY_ENTER][KEY_HALF_PRESS_DOWN] == NULL &&
  760.                 currKeyFuncPtrs[KEY_ENTER][KEY_REPEAT] == NULL && currKeyFuncPtrs[KEY_ENTER][KEY_LONG_PRESS] == NULL)
  762.             {
  763.                 currFuncPtr = currKeyFuncPtrs[KEY_LSK][keyType];
  764.             }
  765.         }
  766.         /* MTK Leo end. */
  768.         if ((keyType == KEY_REPEAT) && (currFuncPtr == NULL) && (keyCode != KEY_RSK) && (keyCode != KEY_LSK))   /* 20040906 Disable repeat for LSK and RSK */
  769.         {
  770.             currFuncPtr = currKeyFuncPtrs[keyCode][KEY_EVENT_DOWN];
  771.         }
  773.     #ifdef __MMI_WGUI_MINI_TAB_BAR__
  774.         if (wgui_if_mini_tab_bar_enable() == MMI_TRUE && keyCode == KEY_LEFT_ARROW && keyType == KEY_EVENT_DOWN)
  775.         {
  776.             currFuncPtr = wgui_mini_tab_bar_goto_prev;
  777.         }
  779.         if (wgui_if_mini_tab_bar_enable() == MMI_TRUE && keyCode == KEY_RIGHT_ARROW && keyType == KEY_EVENT_DOWN)
  780.         {
  781.             currFuncPtr = wgui_mini_tab_bar_goto_next;
  782.         }
  783.     #endif /* __MMI_WGUI_MINI_TAB_BAR__ */ 
  785.     #ifdef __MMI_SCREEN_SNAPSHOT__
  786.         if ((keyType == KEY_LONG_PRESS) && (keyCode == KEY_CAMERA) && (currFuncPtr == NULL))
  787.         {
  788.             currFuncPtr = mmi_camera_scr_snapshot;
  789.         }
  790.     #endif /* __MMI_SCREEN_SNAPSHOT__ */ 
  792.         if (mmi_kbd_get_concurrent_mode() == MMI_FALSE)
  793.         {
  794.             if (keyType == KEY_EVENT_UP)
  795.             {
  796.                 /* release the key */
  797.                 if (pressKey == 1)  /* 0- full up, 1- half down, 2- full down */
  798.                 {
  799.                     currFuncPtr = currKeyFuncPtrs[keyCode][KEY_HALF_PRESS_UP];
  800.                 }
  801.                 else if ((pressKey == 2) && (currKeyFuncPtrs[keyCode][KEY_HALF_PRESS_UP] != NULL))
  802.                 {
  803.                     /* If KEY_EVENT_UP in 2-stage full-pressed key, need call KEY_HALF_PRESS_UP handler first */
  804.                     currKeyFuncPtrs[keyCode][KEY_HALF_PRESS_UP] ();
  805.                 }
  806.                 /* special handling for single-key mode */
  807.                 mmi_frm_reset_internal_key_contex();
  808.             }
  809.         }
  810.         if (currFuncPtr)
  811.         {
  812.         #ifdef __MMI_SUPPORT_DUMP_SCREEN_STRING__
  813.             g_mmi_frm_cntx.dump_screen_info.allow_dump_screen_str = MMI_TRUE;
  814.         #endif
  816. MMI_TRACE( (MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_EXECURKEY_KEYCODE_HDLR,currFuncPtr, keyCode, keyType));
  817. (*currFuncPtr)();
  819.         }
  820.     }
  821.     else
  822.     {
  823.         gEmerencyNoDialed = 0;
  824.     }
  825. }
  828. /*****************************************************************************
  829.  * FUNCTION
  830.  *  ExecuteCurrProtocolHandler
  831.  * DESCRIPTION
  832.  *  executes current protocol func handler
  833.  *  
  834.  *  This is used to executes current protocol func handler
  835.  * PARAMETERS
  836.  *  eventID         [IN]        
  837.  *  MsgStruct       [IN]        
  838.  *  mod_src         [IN]        
  839.  *  peerBuf         [IN]         
  840.  * RETURNS
  841.  *  void
  842.  *****************************************************************************/
  843. void ExecuteCurrProtocolHandler(U16 eventID, void *MsgStruct, int mod_src, void *peerBuf)
  844. {
  845.     /*----------------------------------------------------------------*/
  846.     /* Local Variables                                                */
  847.     /*----------------------------------------------------------------*/
  848.     U16 count = 0;
  850.     /* PsExtFuncPtr currFuncPtr = NULL; */
  851.     PsExtPeerFuncPtr currFuncPtr = NULL;
  852.     PsIntFuncPtr IntFunc = NULL, PostIntFunc = NULL;
  853.     PsExtPeerIntFuncPtr currInterruptFuncPtr = NULL, currPostInterruptFuncPtr = NULL;
  854.     U8 interrup_result = MMI_FALSE; /* False not handle interrupt, True will handle */
  856. #if defined (MMI_EVENT_PROFILING)
  857.     kal_uint32 start_tick, end_tick;
  858.     static kal_uint32 accu_ticks = 0;
  859.     static U32 accu_count = 0;
  860. #endif /* defined (MMI_EVENT_PROFILING) */ 
  862.     /*----------------------------------------------------------------*/
  863.     /* Code Body                                                      */
  864.     /*----------------------------------------------------------------*/
  865. #if defined (MMI_EVENT_PROFILING)
  866.     kal_get_time(&start_tick);
  867. #endif 
  869.     /* Search events in protocol event handler table */
  870.     for (count = 0; count < maxProtocolEvent; count++)
  871.     {
  872.         if (protocolEventHandler[count].eventID == eventID)
  873.         {
  874.             currFuncPtr = (PsExtPeerFuncPtr) protocolEventHandler[count].entryFuncPtr;
  875.             if (count > 0)
  876.             {   /* improve the search efficiently */
  877.                 protocolEventHandler[count].eventID = protocolEventHandler[count - 1].eventID;
  878.                 protocolEventHandler[count].entryFuncPtr = protocolEventHandler[count - 1].entryFuncPtr;
  880.                 protocolEventHandler[count - 1].eventID = eventID;
  881.                 protocolEventHandler[count - 1].entryFuncPtr = (PsFuncPtr) currFuncPtr;
  882.             }
  883.             break;
  884.         }
  885.     }
  887. #if defined (MMI_EVENT_PROFILING)
  888.     PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "ExecuteCurrProtocolHandler count = %d", count));
  889.     accu_count += count;
  890. #endif /* defined (MMI_EVENT_PROFILING) */ 
  892.     /* Search events in interrupt event handler table */
  893.     QueryInterruptHandler(eventID, &IntFunc, &PostIntFunc);
  894.     currInterruptFuncPtr = (PsExtPeerIntFuncPtr) IntFunc;
  895.     currPostInterruptFuncPtr = (PsExtPeerIntFuncPtr) PostIntFunc;
  897.     if (currInterruptFuncPtr)
  898.     {
  899.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_EXECURPTO_INTP_HDLR, eventID));
  900.         interrup_result = (*currInterruptFuncPtr) (MsgStruct, mod_src, peerBuf);
  901.     }
  902.     /* if(currFuncPtr) */
  903.     if ((currFuncPtr) && (!interrup_result))
  904.     {
  905.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_EXECURPTO_HDLR, eventID));
  906.         /* (*currFuncPtr)(MsgStruct,mod_src); */
  907.         (*currFuncPtr) (MsgStruct, mod_src, peerBuf);
  908.     }
  909.     else
  910.     {
  911.         MMI_TRACE((MMI_TRACE_WARNING, MMI_FRM_INFO_EVENT_EXECURPTO_NO_HDLR, eventID));
  912.     }
  914.     if (currPostInterruptFuncPtr)
  915.     {
  916.         (*currPostInterruptFuncPtr) (MsgStruct, mod_src, peerBuf);
  917.     }
  919. #if defined (MMI_EVENT_PROFILING)
  920.     kal_get_time(&end_tick);
  921.     accu_ticks += (end_tick - start_tick);
  922.     PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "ExecuteCurrProtocolHandler accu_count = %d", accu_count));
  923.     PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "ExecuteCurrProtocolHandler accu_ticks = %d", accu_ticks));
  924.     PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "ExecuteCurrProtocolHandler maxProtocolEvent = %d", maxProtocolEvent));
  926. #endif /* defined (MMI_EVENT_PROFILING) */ 
  928. }
  931. /*****************************************************************************
  932.  * FUNCTION
  933.  *  ExecuteCurrExitHandler
  934.  * DESCRIPTION
  935.  *  executes current exit func handler
  936.  *  
  937.  *  This is used to executes current exit func handler
  938.  * PARAMETERS
  939.  *  void
  940.  * RETURNS
  941.  *  void
  942.  *****************************************************************************/
  943. extern void UI_common_screen_exit(void);
  944. extern void UI_common_screen_pre_exit(void);
  946. static void ExecuteCurrExitHandler(void)
  947. {
  948.     /*----------------------------------------------------------------*/
  949.     /* Local Variables                                                */
  950.     /*----------------------------------------------------------------*/
  952.     /*----------------------------------------------------------------*/
  953.     /* Code Body                                                      */
  954.     /*----------------------------------------------------------------*/
  955.     /* MTK added by JL 040115 for create a new function without key clear if need. */
  956.     ExecuteCurrExitHandler_Ext();
  957.     /* it clears all the key handlers, registered by the current screen */
  958.     ClearInputEventHandler(MMI_DEVICE_KEY);
  959. #ifdef __MMI_DOWNLOADABLE_THEMES_SUPPORT__
  960.     mmi_tm_reset_imageid_image_header_pool();
  961. #ifdef __MMI_DLT_CACHE_SUPPORT__
  962.     mmi_tm_clear_ondemand_cache();
  963. #endif 
  964. #endif /* __MMI_DOWNLOADABLE_THEMES_SUPPORT__ */ 
  965.     /* MTK end */
  967. #if defined(__MMI_RESOURCE_ENFB_SUPPORT__)
  968. mmi_frm_resmem_reset(MMI_FRM_RESMEM_TYPE_LOD_ON_DEMAND);
  969. #endif /* __MMI_RESOURCE_ENFB_SUPPORT__ */
  971. }
  974. /*****************************************************************************
  975.  * FUNCTION
  976.  *  ReplaceNewScreenHandler
  977.  * DESCRIPTION
  978.  *  Replace current new screen handler
  979.  *  
  980.  *  This is used to sets current new screen handlers
  981.  * PARAMETERS
  982.  *  scrnID              [IN]        
  983.  *  exitFuncPtr         [IN]        
  984.  *  entryFuncPtr        [IN]        
  985.  * RETURNS
  986.  *  void
  987.  *****************************************************************************/
  988. void ReplaceNewScreenHandler(U16 scrnID, FuncPtr exitFuncPtr, FuncPtr entryFuncPtr)
  989. {
  990.     /*----------------------------------------------------------------*/
  991.     /* Local Variables                                                */
  992.     /*----------------------------------------------------------------*/
  994.     /*----------------------------------------------------------------*/
  995.     /* Code Body                                                      */
  996.     /*----------------------------------------------------------------*/
  997.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETEXIT_HDLR, scrnID));
  998.     currExitScrnID = scrnID;
  999.     currExitFuncPtr = exitFuncPtr;
  1000.     currEntryFuncPtr = entryFuncPtr;
  1001. }
  1004. /*****************************************************************************
  1005.  * FUNCTION
  1006.  *  EntryNewScreen
  1007.  * DESCRIPTION
  1008.  *  To set the current topest screen ID for entry screen function
  1009.  *  
  1010.  *  This is used to executes current exit func handler
  1011.  * PARAMETERS
  1012.  *  newscrnID           [IN]        
  1013.  *  newExitHandler      [IN]        
  1014.  *  newEntryHandler     [IN]        
  1015.  *  peerBuf             [IN]         
  1016.  * RETURNS
  1017.  *  void
  1018.  *****************************************************************************/
  1019. U8 EntryNewScreen(U16 newscrnID, FuncPtr newExitHandler, FuncPtr newEntryHandler, void *peerBuf)
  1020. {
  1021.     /*----------------------------------------------------------------*/
  1022.     /* Local Variables                                                */
  1023.     /*----------------------------------------------------------------*/
  1025.     /*----------------------------------------------------------------*/
  1026.     /* Code Body                                                      */
  1027.     /*----------------------------------------------------------------*/
  1028.     /* store the current Top entry screen */
  1030.     currTopScrnID = newscrnID;
  1031.     /* entry the new screen */
  1032.     ExecuteCurrExitHandler();
  1033.     /* store the exit current Top entry screen */
  1034.     currExitScrnID = newscrnID;
  1036.     if ((newExitHandler != NULL) || (newEntryHandler != NULL))
  1037.     {
  1038.         SetGenericExitHandler(newscrnID, newExitHandler, newEntryHandler);
  1039.     }
  1041.     return MMI_TRUE;
  1042. }
  1045. /*****************************************************************************
  1046.  * FUNCTION
  1047.  *  EntryNewScreen_Ext
  1048.  * DESCRIPTION
  1049.  *  To set the current topest screen ID for entry screen function, without clear keyhandler
  1050.  *  
  1051.  *  This is used to executes current exit func handler
  1052.  * PARAMETERS
  1053.  *  newscrnID           [IN]        
  1054.  *  newExitHandler      [IN]        
  1055.  *  newEntryHandler     [IN]        
  1056.  *  peerBuf             [IN]         
  1057.  * RETURNS
  1058.  *  void
  1059.  *****************************************************************************/
  1060. U8 EntryNewScreen_Ext(U16 newscrnID, FuncPtr newExitHandler, FuncPtr newEntryHandler, void *peerBuf)
  1061. {
  1062.     /*----------------------------------------------------------------*/
  1063.     /* Local Variables                                                */
  1064.     /*----------------------------------------------------------------*/
  1066.     /*----------------------------------------------------------------*/
  1067.     /* Code Body                                                      */
  1068.     /*----------------------------------------------------------------*/
  1069.     /* store the current Top entry screen */
  1070.     currTopScrnID = newscrnID;
  1071.     /* entry the new screen */
  1072.     ExecuteCurrExitHandler_Ext();
  1073.     /* store the exit current Top entry screen */
  1074.     currExitScrnID = newscrnID;
  1075.     if ((newExitHandler != NULL) || (newEntryHandler != NULL))
  1076.     {
  1077.         SetGenericExitHandler(newscrnID, newExitHandler, newEntryHandler);
  1078.     }
  1080.     return MMI_TRUE;
  1081. }
  1084. /*****************************************************************************
  1085.  * FUNCTION
  1086.  *  ExecuteCurrExitHandler_Ext
  1087.  * DESCRIPTION
  1088.  *  executes current exit func handler without clear keys
  1089.  *  
  1090.  *  This is used to executes current exit func handler
  1091.  * PARAMETERS
  1092.  *  void
  1093.  * RETURNS
  1094.  *  void
  1095.  *****************************************************************************/
  1096. /* MTK added by JL for keypad without clearall requirement */
  1097. void ExecuteCurrExitHandler_Ext(void)
  1098. {
  1099.     /*----------------------------------------------------------------*/
  1100.     /* Local Variables                                                */
  1101.     /*----------------------------------------------------------------*/
  1102.     U8 count = 0;
  1104.     /*----------------------------------------------------------------*/
  1105.     /* Code Body                                                      */
  1106.     /*----------------------------------------------------------------*/
  1107. #ifdef __MMI_SUPPORT_DUMP_SCREEN_STRING__
  1108.     /* Clear g_mmi_frm_cntx.dump_screen_info.backup_string */
  1109.     g_mmi_frm_cntx.dump_screen_info.backup_string[0] = 0;
  1110.     g_mmi_frm_cntx.dump_screen_info.backup_string[1] = 0;
  1111.     g_mmi_frm_cntx.dump_screen_info.allow_dump_screen_str = MMI_TRUE;
  1112. #endif
  1113.     /* Failsafe common function before exit screen */
  1114.     UI_common_screen_pre_exit();
  1116.     for (count = 0; count < MAX_SUB_MENUS; count++)
  1117.     {
  1118.         subMenuDataPtrs[count] = subMenuData[count];
  1119.     }
  1121.     if (currEntryFuncPtr || currExitFuncPtr)
  1122.     {
  1123.         ClearAllInterruptEventHandler();
  1124.     }
  1126.     /* call GenericExitScreen if currEntryFuncPtr is not NULL */
  1127.     if (currEntryFuncPtr)
  1128.     {
  1129.         GenericExitScreen(currExitScrnID, currEntryFuncPtr);
  1130.     }
  1132.     if (currExitFuncPtr)
  1133.     {
  1134.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_EXIT_HDLR));
  1135.         mmu_frm_execute_scrn_exit_handler = MMI_TRUE;
  1136.         (*currExitFuncPtr) ();
  1137.         mmu_frm_execute_scrn_exit_handler = MMI_FALSE;
  1138.     }
  1140.     currEntryFuncPtr = NULL;
  1141.     currExitFuncPtr = NULL;
  1143.     /* Failsafe common screen exit function   */
  1144.     UI_common_screen_exit();
  1146.     /* it clears all the key handlers, registered by the current screen */
  1147.     IsBackHistory = FALSE;
  1149.     /* To dump the history memory */
  1150.     HistoryDump();
  1152. }
  1155. /*****************************************************************************
  1156.  * FUNCTION
  1157.  *  mmi_execute_scrn_exit_func
  1158.  * DESCRIPTION
  1159.  *  check if framework executes the screen's exit handler
  1160.  *  
  1161.  *  This is used to executes current exit func handler
  1162.  * PARAMETERS
  1163.  *  void
  1164.  * RETURNS
  1165.  *  MMI_BOOL
  1166.  *****************************************************************************/
  1167. MMI_BOOL mmi_execute_scrn_exit_func(void)
  1168. {
  1169.     return mmu_frm_execute_scrn_exit_handler;
  1170. }
  1173. /*****************************************************************************
  1174.  * FUNCTION
  1175.  *  ExecuteCurrHiliteHandler
  1176.  * DESCRIPTION
  1177.  *  executes current hilite func handler
  1178.  *  
  1179.  *  This is used to executes current hilite func handler
  1180.  * PARAMETERS
  1181.  *  hiliteid        [IN]        
  1182.  * RETURNS
  1183.  *  void
  1184.  *****************************************************************************/
  1185. void ExecuteCurrHiliteHandler(S32 hiliteid)
  1186. {
  1187.     /*----------------------------------------------------------------*/
  1188.     /* Local Variables                                                */
  1189.     /*----------------------------------------------------------------*/
  1191.     /*----------------------------------------------------------------*/
  1192.     /* Code Body                                                      */
  1193.     /*----------------------------------------------------------------*/
  1194.     /* To avoid the arrow left key to entry unexpected function, while other APP need they shall register again as BY request. */
  1195.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1197.     ExecuteCurrHiliteHandler_Ext(hiliteid);
  1199. }
  1202. /*****************************************************************************
  1203.  * FUNCTION
  1204.  *  ExecuteCurrHiliteHandler_Ext
  1205.  * DESCRIPTION
  1206.  *  
  1207.  * PARAMETERS
  1208.  *  hiliteid        [IN]        
  1209.  * RETURNS
  1210.  *  void
  1211.  *****************************************************************************/
  1212. void ExecuteCurrHiliteHandler_Ext(S32 hiliteid)
  1213. {
  1214.     /*----------------------------------------------------------------*/
  1215.     /* Local Variables                                                */
  1216.     /*----------------------------------------------------------------*/
  1217.     FuncPtr currFuncPtr = NULL;
  1218.     S32 hiliteItemID;
  1220.     /*----------------------------------------------------------------*/
  1221.     /* Code Body                                                      */
  1222.     /*----------------------------------------------------------------*/
  1223.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_EXECURHILIHTE_HDLR, hiliteid));
  1225.     currHiliteID = (U16) hiliteid;
  1226.     if (currParentID == 0)
  1227.     {
  1228.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_EVENT_EXECURHILIHTE_HDLR));
  1229.         return;
  1230.     }
  1232.     /* check if menuitem is hidden */
  1233.     hiliteItemID = GetSeqItemId_Ext((U16) currParentID, (S16) hiliteid);
  1234.     currFuncPtr = maxHiliteInfo[hiliteItemID].entryFuncPtr;
  1235.     if (currFuncPtr)
  1236.     {
  1237.         (*currFuncPtr) ();
  1238.     }
  1239. }
  1242. /*****************************************************************************
  1243.  * FUNCTION
  1244.  *  GetCurrHiliteID
  1245.  * DESCRIPTION
  1246.  *  Returns the index of the currently highlighted menu item
  1247.  * PARAMETERS
  1248.  *  void
  1249.  * RETURNS
  1250.  *  void
  1251.  *****************************************************************************/
  1252. U16 GetCurrHiliteID(void)
  1253. {
  1254.     /*----------------------------------------------------------------*/
  1255.     /* Local Variables                                                */
  1256.     /*----------------------------------------------------------------*/
  1258.     /*----------------------------------------------------------------*/
  1259.     /* Code Body                                                      */
  1260.     /*----------------------------------------------------------------*/
  1261.     return currHiliteID;
  1262. }
  1265. /*****************************************************************************
  1266.  * FUNCTION
  1267.  *  SetHiliteHandler
  1268.  * DESCRIPTION
  1269.  *  Sets hilite func handlers
  1270.  *  
  1271.  *  This is used to set hilite func handlers
  1272.  * PARAMETERS
  1273.  *  itemid              [IN]        
  1274.  *  hiliteFuncPtr       [IN]        
  1275.  * RETURNS
  1276.  *  void
  1277.  *****************************************************************************/
  1278. void SetHiliteHandler(U16 itemid, FuncPtr hiliteFuncPtr)
  1279. {
  1280.     /*----------------------------------------------------------------*/
  1281.     /* Local Variables                                                */
  1282.     /*----------------------------------------------------------------*/
  1284.     /*----------------------------------------------------------------*/
  1285.     /* Code Body                                                      */
  1286.     /*----------------------------------------------------------------*/
  1287.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETCURHILIHTE_HDLR, itemid));
  1289.     maxHiliteInfo[itemid].entryFuncPtr = hiliteFuncPtr;
  1290. }
  1293. /*****************************************************************************
  1294.  * FUNCTION
  1295.  *  ClearHiliteHandler
  1296.  * DESCRIPTION
  1297.  *  Clear hilite handler
  1298.  *  
  1299.  *  This is used to clear hilite func handlers for a particular menu item
  1300.  * PARAMETERS
  1301.  *  itemid      [IN]        
  1302.  * RETURNS
  1303.  *  void
  1304.  *****************************************************************************/
  1305. void ClearHiliteHandler(U16 itemid)
  1306. {
  1307.     /*----------------------------------------------------------------*/
  1308.     /* Local Variables                                                */
  1309.     /*----------------------------------------------------------------*/
  1311.     /*----------------------------------------------------------------*/
  1312.     /* Code Body                                                      */
  1313.     /*----------------------------------------------------------------*/
  1314.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRCURHILIHTE_HDLR, itemid));
  1316.     maxHiliteInfo[itemid].entryFuncPtr = NULL;
  1317. }
  1320. /*****************************************************************************
  1321.  * FUNCTION
  1322.  *  ConstructHintsList
  1323.  * DESCRIPTION
  1324.  *  Constructs Hint List for a static menu screen
  1325.  * PARAMETERS
  1326.  *  parentID        [IN]        
  1327.  *  hintArray       [IN]        
  1328.  * RETURNS
  1329.  *  void
  1330.  *****************************************************************************/
  1331. extern MMI_BOOL mmi_frm_test_menu_item_hide(U16 menu_item_id);
  1332. void ConstructHintsList(U16 parentID, U8 **hintArray)
  1333. {
  1334.     /*----------------------------------------------------------------*/
  1335.     /* Local Variables                                                */
  1336.     /*----------------------------------------------------------------*/
  1337.     U8 i, noOfChild;
  1338.     U16 hiliteItemID[MAX_SUB_MENUS];
  1339.     U8 idx = 0;
  1341.     /*----------------------------------------------------------------*/
  1342.     /* Code Body                                                      */
  1343.     /*----------------------------------------------------------------*/
  1344.     noOfChild = (U8) GetNumOfChild(parentID);
  1345.     for (i = 0; i < noOfChild; i++)
  1346.     {
  1347.         hiliteItemID[i] = GetSeqItemId((U16) parentID, (S16) i);
  1348.         /* check if menuitem is hidden */
  1349.         if (!mmi_frm_test_menu_item_hide(hiliteItemID[i]))  /* the menuitem is not hidden */
  1350.         {
  1351.             if (maxHiliteInfo[hiliteItemID[i]].hintFuncPtr)
  1352.             {
  1353.                 (*maxHiliteInfo[hiliteItemID[i]].hintFuncPtr) (idx);
  1354.                 hintArray[idx] = hintData[idx];
  1355.                 idx++;
  1356.             }
  1357.             else
  1358.             {
  1359.                 hintArray[idx++] = NULL;
  1360.             }
  1361.         }
  1362.     }
  1363. }
  1366. /*****************************************************************************
  1367.  * FUNCTION
  1368.  *  SetHintHandler
  1369.  * DESCRIPTION
  1370.  *  Sets Hint Func Handlers
  1371.  * PARAMETERS
  1372.  *  itemid          [IN]        FuncPtr hiliteFuncPtr
  1373.  *  hintFuncPtr     [IN]        
  1374.  * RETURNS
  1375.  *  void
  1376.  *****************************************************************************/
  1377. void SetHintHandler(U16 itemid, FuncPtrShort hintFuncPtr)
  1378. {
  1379.     /*----------------------------------------------------------------*/
  1380.     /* Local Variables                                                */
  1381.     /*----------------------------------------------------------------*/
  1383.     /*----------------------------------------------------------------*/
  1384.     /* Code Body                                                      */
  1385.     /*----------------------------------------------------------------*/
  1386.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETHINT_HDLR, itemid));
  1388.     maxHiliteInfo[itemid].hintFuncPtr = hintFuncPtr;
  1389. }
  1392. /*****************************************************************************
  1393.  * FUNCTION
  1394.  *  ClearHintHandler
  1395.  * DESCRIPTION
  1396.  *  clears hint handlers
  1397.  *  
  1398.  *  This is used to clear hint func handlers
  1399.  * PARAMETERS
  1400.  *  itemid      [IN]        
  1401.  * RETURNS
  1402.  *  void
  1403.  *****************************************************************************/
  1404. void ClearHintHandler(U16 itemid)
  1405. {
  1406.     /*----------------------------------------------------------------*/
  1407.     /* Local Variables                                                */
  1408.     /*----------------------------------------------------------------*/
  1410.     /*----------------------------------------------------------------*/
  1411.     /* Code Body                                                      */
  1412.     /*----------------------------------------------------------------*/
  1413.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRHINT_HDLR, itemid));
  1415.     maxHiliteInfo[itemid].hintFuncPtr = NULL;
  1416. }
  1419. /*****************************************************************************
  1420.  * FUNCTION
  1421.  *  SetParentHandler
  1422.  * DESCRIPTION
  1423.  *  sets current parent item id
  1424.  *  
  1425.  *  This is used to set current parent item id
  1426.  * PARAMETERS
  1427.  *  parentID        [IN]        
  1428.  * RETURNS
  1429.  *  void
  1430.  *****************************************************************************/
  1431. void SetParentHandler(U16 parentID)
  1432. {
  1433.     /*----------------------------------------------------------------*/
  1434.     /* Local Variables                                                */
  1435.     /*----------------------------------------------------------------*/
  1437.     /*----------------------------------------------------------------*/
  1438.     /* Code Body                                                      */
  1439.     /*----------------------------------------------------------------*/
  1440.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETPARENT_HDLR, parentID));
  1442.     currParentID = parentID;
  1443. }
  1445. /* MTK Brian added for AT+CVIB, 2003/11/23 */
  1448. /*****************************************************************************
  1449.  * FUNCTION
  1450.  *  GetParentHandler
  1451.  * DESCRIPTION
  1452.  *  
  1453.  * PARAMETERS
  1454.  *  void
  1455.  * RETURNS
  1456.  *  
  1457.  *****************************************************************************/
  1458. U16 GetParentHandler(void)
  1459. {
  1460.     /*----------------------------------------------------------------*/
  1461.     /* Local Variables                                                */
  1462.     /*----------------------------------------------------------------*/
  1464.     /*----------------------------------------------------------------*/
  1465.     /* Code Body                                                      */
  1466.     /*----------------------------------------------------------------*/
  1467.     return currParentID;
  1468. }
  1471. /*****************************************************************************
  1472.  * FUNCTION
  1473.  *  SetKeyHandler
  1474.  * DESCRIPTION
  1475.  *  sets the curent screen key handlers
  1476.  *  
  1477.  *  This is used to set the curent screen key handlers
  1478.  * PARAMETERS
  1479.  *  funcPtr     [IN]        
  1480.  *  keyCode     [IN]        
  1481.  *  keyType     [IN]        
  1482.  * RETURNS
  1483.  *  void
  1484.  *****************************************************************************/
  1485. void SetKeyHandler(FuncPtr funcPtr, U16 keyCode, U16 keyType)
  1486. {
  1487.     /*----------------------------------------------------------------*/
  1488.     /* Local Variables                                                */
  1489.     /*----------------------------------------------------------------*/
  1491.     /*----------------------------------------------------------------*/
  1492.     /* Code Body                                                      */
  1493.     /*----------------------------------------------------------------*/
  1494.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETKEY_HDLR, keyCode, keyType, funcPtr));
  1496.     MMI_ASSERT((keyCode < MAX_KEYS) && (keyType < MAX_KEY_TYPE));
  1498.     currKeyFuncPtrs[keyCode][keyType] = funcPtr;
  1499. }
  1502. /*****************************************************************************
  1503.  * FUNCTION
  1504.  *  GetKeyHandler
  1505.  * DESCRIPTION
  1506.  *  return the curent screen key handlers
  1507.  *  
  1508.  *  This is used to set the curent screen key handlers
  1509.  * PARAMETERS
  1510.  *  keyCode     [IN]        
  1511.  *  keyType     [IN]        
  1512.  * RETURNS
  1513.  *  void
  1514.  *****************************************************************************/
  1515. FuncPtr GetKeyHandler(U16 keyCode, U16 keyType)
  1516. {
  1517.     /*----------------------------------------------------------------*/
  1518.     /* Local Variables                                                */
  1519.     /*----------------------------------------------------------------*/
  1521.     /*----------------------------------------------------------------*/
  1522.     /* Code Body                                                      */
  1523.     /*----------------------------------------------------------------*/
  1524.     MMI_ASSERT((keyCode < MAX_KEYS) && (keyType < MAX_KEY_TYPE));
  1526.     return (currKeyFuncPtrs[keyCode][keyType]);
  1527. }
  1530. /*****************************************************************************
  1531.  * FUNCTION
  1532.  *  SetGroupKeyHandler
  1533.  * DESCRIPTION
  1534.  *  sets the curent screen same key handler to the group pf keycodes
  1535.  *  
  1536.  *  This is used to set the same key handler for a group of keycodes.
  1537.  * PARAMETERS
  1538.  *  funcPtr         [IN]        
  1539.  *  keyCodes        [IN]        
  1540.  *  len             [IN]        
  1541.  *  keyType         [IN]        
  1542.  * RETURNS
  1543.  *  void
  1544.  *****************************************************************************/
  1545. void SetGroupKeyHandler(FuncPtr funcPtr, PU16 keyCodes, U8 len, U16 keyType)
  1546. {
  1547.     /*----------------------------------------------------------------*/
  1548.     /* Local Variables                                                */
  1549.     /*----------------------------------------------------------------*/
  1550.     U8 count;
  1552.     /*----------------------------------------------------------------*/
  1553.     /* Code Body                                                      */
  1554.     /*----------------------------------------------------------------*/
  1555.     MMI_ASSERT((len <= MAX_KEYS) && (keyType < MAX_KEY_TYPE));
  1557.     for (count = 0; count < len; count++)
  1558.     {
  1559.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETGROUPKEY_HDLR, keyCodes[count], keyType));
  1560.         currKeyFuncPtrs[keyCodes[count]][keyType] = funcPtr;
  1561.     }
  1562. }
  1565. /*****************************************************************************
  1566.  * FUNCTION
  1567.  *  ClearKeyHandler
  1568.  * DESCRIPTION
  1569.  *  clears the current screen key handlers
  1570.  *  
  1571.  *  This is used to clears the current screen key handlers
  1572.  * PARAMETERS
  1573.  *  keyCode     [IN]        
  1574.  *  keyType     [IN]        
  1575.  * RETURNS
  1576.  *  void
  1577.  *****************************************************************************/
  1578. void ClearKeyHandler(U16 keyCode, U16 keyType)
  1579. {
  1580.     /*----------------------------------------------------------------*/
  1581.     /* Local Variables                                                */
  1582.     /*----------------------------------------------------------------*/
  1584.     /*----------------------------------------------------------------*/
  1585.     /* Code Body                                                      */
  1586.     /*----------------------------------------------------------------*/
  1587.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRKEY_HDLR, keyCode, keyType));
  1589.     MMI_ASSERT((keyCode < MAX_KEYS) && (keyType < MAX_KEY_TYPE));
  1591.     currKeyFuncPtrs[keyCode][keyType] = NULL;
  1592. }
  1595. /*****************************************************************************
  1596.  * FUNCTION
  1597.  *  ClearAllKeyHandler
  1598.  * DESCRIPTION
  1599.  *  clears all the current screen key handlers
  1600.  *  
  1601.  *  This is used to clears all the current screen key handlers
  1602.  * PARAMETERS
  1603.  *  void
  1604.  * RETURNS
  1605.  *  void
  1606.  *****************************************************************************/
  1607. void ClearAllKeyHandler(void)
  1608. {
  1609.     /*----------------------------------------------------------------*/
  1610.     /* Local Variables                                                */
  1611.     /*----------------------------------------------------------------*/
  1612.     U16 keyCode = 0;
  1613.     U16 keyType = 0;
  1615.     /*----------------------------------------------------------------*/
  1616.     /* Code Body                                                      */
  1617.     /*----------------------------------------------------------------*/
  1618.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRALLKEY_HDLR));
  1620.     for (keyCode = 0; keyCode < MAX_KEYS; keyCode++)
  1621.     {
  1622.         for (keyType = 0; keyType < MAX_KEY_TYPE; keyType++)
  1623.         {
  1624.             currKeyFuncPtrs[keyCode][keyType] = NULL;
  1625.         }
  1626.     }
  1627.     PowerAndEndKeyHandler();
  1629.     SetDefaultVolumeKeyHandlers();
  1630. }
  1633. /*****************************************************************************
  1634.  * FUNCTION
  1635.  *  ClearInputEventHandler
  1636.  * DESCRIPTION
  1637.  *  Clear input device event handlers
  1638.  *  
  1639.  *  This is used to clear input device event handlers
  1640.  * PARAMETERS
  1641.  *  device      [IN]        Type
  1642.  * RETURNS
  1643.  *  void
  1644.  *****************************************************************************/
  1645. void ClearInputEventHandler(U16 device)
  1646. {
  1647.     /*----------------------------------------------------------------*/
  1648.     /* Local Variables                                                */
  1649.     /*----------------------------------------------------------------*/
  1651.     /*----------------------------------------------------------------*/
  1652.     /* Code Body                                                      */
  1653.     /*----------------------------------------------------------------*/
  1654.     if (device & MMI_DEVICE_KEY)
  1655.     {
  1656.         ClearAllKeyHandler();
  1657.     }
  1659. #ifdef  __MMI_TOUCH_SCREEN__
  1660. if ( device & MMI_DEVICE_PEN )
  1661. {
  1662. wgui_clear_pen_handlers();
  1663. }
  1664. #endif
  1665. }
  1668. /*****************************************************************************
  1669.  * FUNCTION
  1670.  *  PowerAndEndKeyHandler
  1671.  * DESCRIPTION
  1672.  *  sets power key & end key handlers
  1673.  *  
  1674.  *  This is used to set power key & end key handlers
  1675.  * PARAMETERS
  1676.  *  void
  1677.  * RETURNS
  1678.  *  void
  1679.  *****************************************************************************/
  1680. #if defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__)
  1681. extern BOOL DirectMode;
  1682. extern void CallBackPowerOnAnimationCompleteWrapper(void);
  1683. #endif /* defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__) */ 
  1685. void PowerAndEndKeyHandler(void)
  1686. {
  1687.     /*----------------------------------------------------------------*/
  1688.     /* Local Variables                                                */
  1689.     /*----------------------------------------------------------------*/
  1691.     /*----------------------------------------------------------------*/
  1692.     /* Code Body                                                      */
  1693.     /*----------------------------------------------------------------*/
  1694.    /**
  1695.     * The end key must not be registered to
  1696.     * Go to IDle screen in case any call exists on the
  1697.     * the phone. This is a temporary solution for fixing the
  1698.     * CM bugs
  1699.     */
  1700.     if (isInCall() && !GetWapCallPresent())
  1701.     {
  1702. #ifdef __MMI_VOIP__
  1703.         if (GetTotalCallCount() != 0) /* disconnect gsm call */
  1704.         {
  1705.             currKeyFuncPtrs[KEY_END][KEY_EVENT_DOWN] = HangupAllCalls;
  1706.         }
  1707.         else if (mmi_voip_app_total_call() != 0) /* disconnect voip call */
  1708.         {
  1709.             currKeyFuncPtrs[KEY_END][KEY_EVENT_DOWN] = mmi_voip_entry_ans_to_disconn_voip;
  1710.         }
  1711. #else
  1712.         currKeyFuncPtrs[KEY_END][KEY_EVENT_DOWN] = HangupAllCalls;
  1713. #endif
  1714.     }
  1715.     else
  1716.     {
  1717.         if (mmi_bootup_is_in_security_check() == MMI_FALSE)
  1718.         {
  1719.             /**
  1720.             * The end key should end all the existing calls
  1721.             *  and screen should be the last screen thru call menu.
  1722.             */
  1723.             #ifdef __MMI_EMAIL__
  1724.                 if (mmi_email_util_get_stop_cause() == EMAIL_MODULE_ACTIVE_NOW)
  1725.                 {
  1726.                     currKeyFuncPtrs[KEY_END][KEY_EVENT_DOWN] = mmi_email_main_goto_idle;
  1727.                 }
  1728.                 else if (!gSecuritySetupContext.PINBlocked)
  1729.             #else /* __MMI_EMAIL__ */ 
  1730.                 if (!gSecuritySetupContext.PINBlocked)
  1731.             #endif /* __MMI_EMAIL__ */ 
  1732.                 {
  1733.                     currKeyFuncPtrs[KEY_END][KEY_EVENT_DOWN] = DisplayIdleScreen;
  1734.                 }
  1735.         }
  1736.     }
  1738. #if defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__)
  1739.     if (DirectMode)
  1740.     {
  1741.         currKeyFuncPtrs[KEY_END][KEY_EVENT_DOWN] = CallBackPowerOnAnimationCompleteWrapper;
  1742.     }
  1743. #endif /* defined(__DIRECT_ENTRY_FACTORY_MODE_ON_BOOTUP__) */ 
  1745.     if (!g_keylock_context.gKeyPadLockFlag)
  1746.     {
  1747.         mmi_frm_set_default_power_onoff_key();
  1748.     }
  1749. }
  1752. /*****************************************************************************
  1753.  * FUNCTION
  1754.  *  SetProtocolEventHandler
  1755.  * DESCRIPTION
  1756.  *  sets protocol event handler
  1757.  *  
  1758.  *  This is used to set protocol event handler
  1759.  * PARAMETERS
  1760.  *  funcPtr     [IN]        
  1761.  *  eventID     [IN]        
  1762.  * RETURNS
  1763.  *  void
  1764.  *****************************************************************************/
  1765. void SetProtocolEventHandler(PsFuncPtr funcPtr, U16 eventID)
  1766. {
  1767.     /*----------------------------------------------------------------*/
  1768.     /* Local Variables                                                */
  1769.     /*----------------------------------------------------------------*/
  1770.     static U16 maxUsedInHistory = 0;
  1771.     U16 count;
  1772.     S16 i, firstNotUsed;
  1773.     S16 pos;
  1775.     /*----------------------------------------------------------------*/
  1776.     /* Code Body                                                      */
  1777.     /*----------------------------------------------------------------*/
  1778.     MMI_ASSERT(eventID != 0);
  1779.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETPTO_HDLR, eventID, funcPtr, usedProtocolEvent,
  1780.                maxProtocolEvent));
  1782.     /* serach */
  1783.     pos = -1;
  1784.     firstNotUsed = -1;
  1785.     for (count = 0; count < maxProtocolEvent; count++)
  1786.     {
  1787.         if (protocolEventHandler[count].eventID == eventID)
  1788.         {
  1789.             pos = count;
  1790.             break;
  1791.         }
  1792.         /* BTW, find a non-used item */ ;
  1793.         if ((firstNotUsed == -1) && (protocolEventHandler[count].eventID == MMI_EVENT_INVALID))
  1794.         {
  1795.             firstNotUsed = count;
  1796.         }
  1797.     }
  1799.     if (pos != -1)
  1800.     {
  1801.         /* found */
  1802.         if (funcPtr != NULL)
  1803.         {
  1804.             /* just need to update */
  1805.             protocolEventHandler[pos].entryFuncPtr = funcPtr;
  1806.         }
  1807.         else
  1808.         {
  1809.             /* reset it */
  1810.             protocolEventHandler[pos].eventID = MMI_EVENT_INVALID;
  1811.             protocolEventHandler[pos].entryFuncPtr = NULL;
  1812.             usedProtocolEvent--;
  1813.         }
  1814.     }
  1815.     else
  1816.     {
  1817.         /* not found */
  1818.         if (funcPtr != NULL)
  1819.         {
  1820.             /* newly set */
  1821.             if (firstNotUsed != -1)
  1822.             {
  1823.                 pos = firstNotUsed;
  1824.             }
  1825.             else
  1826.             {
  1827.                 /* need to enlarge current searching list */
  1828.                 pos = maxProtocolEvent;
  1829.                 maxProtocolEvent++;
  1830.                 MMI_ASSERT(maxProtocolEvent < MAX_PROTOCOL_EVENT);
  1831.             }
  1832.             usedProtocolEvent++;
  1833.             protocolEventHandler[pos].eventID = eventID;
  1834.             protocolEventHandler[pos].entryFuncPtr = funcPtr;
  1835.         }
  1836.         else
  1837.         {
  1838.             /* do nothing */
  1839.         }
  1840.     }
  1842.     /* recycle not-used items in the tail of list. It is for searching efficency */
  1843.     for (i = (maxProtocolEvent - 1); i >= 0; i--)
  1844.     {
  1845.         if (protocolEventHandler[i].eventID != MMI_EVENT_INVALID)
  1846.         {
  1847.             break;
  1848.         }
  1849.     }
  1850.     maxProtocolEvent = i + 1;
  1852.     /* record the max value for array size analysis */
  1853.     if (maxUsedInHistory < maxProtocolEvent)
  1854.     {
  1855.         PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "SetProtocolEventHandler old maxUsedInHistory = %d", maxUsedInHistory));
  1856.         maxUsedInHistory = maxProtocolEvent;
  1857.         PRINT_INFORMATION_2((MMI_TRACE_G1_FRM, "SetProtocolEventHandler maxUsedInHistory = %d", maxUsedInHistory));
  1858.     }
  1860.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETPTO_HDLR, eventID, funcPtr, usedProtocolEvent,
  1861.                maxProtocolEvent));
  1862. }
  1865. /*****************************************************************************
  1866.  * FUNCTION
  1867.  *  ClearProtocolEventHandler
  1868.  * DESCRIPTION
  1869.  *  clears protocol event handler
  1870.  *  
  1871.  *  This is used to clear protocol event handler
  1872.  * PARAMETERS
  1873.  *  eventID     [IN]        
  1874.  * RETURNS
  1875.  *  void
  1876.  *****************************************************************************/
  1877. void ClearProtocolEventHandler(U16 eventID)
  1878. {
  1879.     /*----------------------------------------------------------------*/
  1880.     /* Local Variables                                                */
  1881.     /*----------------------------------------------------------------*/
  1883.     /*----------------------------------------------------------------*/
  1884.     /* Code Body                                                      */
  1885.     /*----------------------------------------------------------------*/
  1886.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRPTO_HDLR, eventID));
  1887.     SetProtocolEventHandler(NULL, eventID);
  1888. }
  1891. /*****************************************************************************
  1892.  * FUNCTION
  1893.  *  ClearAllProtocolEventHandler
  1894.  * DESCRIPTION
  1895.  *  clears all the protocol event handler
  1896.  *  
  1897.  *  This is used to clear all the protocol event handlers
  1898.  * PARAMETERS
  1899.  *  void
  1900.  * RETURNS
  1901.  *  void
  1902.  *****************************************************************************/
  1903. void ClearAllProtocolEventHandler(void)
  1904. {
  1905.     /*----------------------------------------------------------------*/
  1906.     /* Local Variables                                                */
  1907.     /*----------------------------------------------------------------*/
  1908.     U16 count = 0;
  1910.     /*----------------------------------------------------------------*/
  1911.     /* Code Body                                                      */
  1912.     /*----------------------------------------------------------------*/
  1913.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRALLPTO_HDLR));
  1915.     for (count = 0; count < maxProtocolEvent; count++)
  1916.     {
  1917.         protocolEventHandler[count].eventID = 0;
  1918.         protocolEventHandler[count].entryFuncPtr = NULL;
  1919.     }
  1920.     usedProtocolEvent = 0;
  1922. }
  1925. /*****************************************************************************
  1926.  * FUNCTION
  1927.  *  SetEntryHandler
  1928.  * DESCRIPTION
  1929.  *  sets current screen entry handlers
  1930.  *  
  1931.  *  This is used to sets current screen entry handlers
  1932.  * PARAMETERS
  1933.  *  scrnID              [IN]        
  1934.  *  entryFuncPtr        [IN]        
  1935.  * RETURNS
  1936.  *  void
  1937.  *****************************************************************************/
  1938. void SetEntryHandler(U16 scrnID, FuncPtr entryFuncPtr)
  1939. {
  1940.     /*----------------------------------------------------------------*/
  1941.     /* Local Variables                                                */
  1942.     /*----------------------------------------------------------------*/
  1944.     /*----------------------------------------------------------------*/
  1945.     /* Code Body                                                      */
  1946.     /*----------------------------------------------------------------*/
  1947.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETENTRY_HDLR, scrnID));
  1948.     currEntryFuncPtr = entryFuncPtr;
  1949. }
  1952. /*****************************************************************************
  1953.  * FUNCTION
  1954.  *  ClearEntryHandler
  1955.  * DESCRIPTION
  1956.  *  clears current screen entry handlers
  1957.  *  
  1958.  *  This is used to clears current screen e1ntry handlers
  1959.  * PARAMETERS
  1960.  *  void
  1961.  * RETURNS
  1962.  *  void
  1963.  *****************************************************************************/
  1964. void ClearEntryHandler(void)
  1965. {
  1966.     /*----------------------------------------------------------------*/
  1967.     /* Local Variables                                                */
  1968.     /*----------------------------------------------------------------*/
  1970.     /*----------------------------------------------------------------*/
  1971.     /* Code Body                                                      */
  1972.     /*----------------------------------------------------------------*/
  1973.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRENTRY_HDLR));
  1974.     currEntryFuncPtr = NULL;
  1976. }
  1979. /*****************************************************************************
  1980.  * FUNCTION
  1981.  *  SetGenericExitHandler
  1982.  * DESCRIPTION
  1983.  *  Generic function to set exit screen handler.
  1984.  *  Store current screen id, exit function, and entry function.
  1985.  * PARAMETERS
  1986.  *  scrnID              [IN]        Screen ID
  1987.  *  exitFuncPtr         [IN]        Exit function pointer
  1988.  *  entryFuncPtr        [IN]        Entry function pointer
  1989.  * RETURNS
  1990.  *  void
  1991.  *****************************************************************************/
  1992. static void SetGenericExitHandler(U16 scrnID, FuncPtr exitFuncPtr, FuncPtr entryFuncPtr)
  1993. {
  1994.     /*----------------------------------------------------------------*/
  1995.     /* Local Variables                                                */
  1996.     /*----------------------------------------------------------------*/
  1998.     /*----------------------------------------------------------------*/
  1999.     /* Code Body                                                      */
  2000.     /*----------------------------------------------------------------*/
  2001.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETGEN_EXIT_HDLR, scrnID));
  2003.     currExitScrnID = scrnID;
  2004.     currExitFuncPtr = exitFuncPtr;
  2005.     currEntryFuncPtr = entryFuncPtr;
  2006. }
  2009. /*****************************************************************************
  2010.  * FUNCTION
  2011.  *  GenericExitInlineScreen
  2012.  * DESCRIPTION
  2013.  *  Generic exit inline editor screen handler.
  2014.  *  Add screen related data to histoy.
  2015.  * PARAMETERS
  2016.  *  scrnID              [IN]        Screen ID
  2017.  *  entryFuncPtr        [IN]        Entry function pointer
  2018.  * RETURNS
  2019.  *  void
  2020.  *****************************************************************************/
  2021. void GenericExitInlineScreen(U16 scrnID, FuncPtr entryFuncPtr)
  2022. {
  2023.     /*----------------------------------------------------------------*/
  2024.     /* Local Variables                                                */
  2025.     /*----------------------------------------------------------------*/
  2026.     history h;
  2027.     U16 inputBufferSize;
  2029.     /*----------------------------------------------------------------*/
  2030.     /* Code Body                                                      */
  2031.     /*----------------------------------------------------------------*/
  2032.     CloseCategory57Screen();
  2033.     h.scrnID = scrnID;
  2034.     h.entryFuncPtr = entryFuncPtr;
  2035.     GetCategoryHistory(h.guiBuffer);
  2036.     inputBufferSize = (U16) GetCategory57DataSize();
  2037.     GetCategory57Data((U8*) h.inputBuffer);
  2038.     AddNHistory(h, inputBufferSize);
  2039. }
  2042. /*****************************************************************************
  2043.  * FUNCTION
  2044.  *  GenericExitScreen
  2045.  * DESCRIPTION
  2046.  *  Generic exit screen handler.
  2047.  *  Add screen related data to histoy.
  2048.  * PARAMETERS
  2049.  *  scrnID              [IN]        Screen ID
  2050.  *  entryFuncPtr        [IN]        Entry function pointer
  2051.  * RETURNS
  2052.  *  void
  2053.  *****************************************************************************/
  2054. void GenericExitScreen(U16 scrnID, FuncPtr entryFuncPtr)
  2055. {
  2056.     /*----------------------------------------------------------------*/
  2057.     /* Local Variables                                                */
  2058.     /*----------------------------------------------------------------*/
  2059.     history h;
  2060.     U16 nHistory = 0;
  2062.     /*----------------------------------------------------------------*/
  2063.     /* Code Body                                                      */
  2064.     /*----------------------------------------------------------------*/
  2065.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_EXEGEN_EXIT_HDLR, scrnID));
  2067.     h.scrnID = scrnID;
  2068.     h.entryFuncPtr = entryFuncPtr;
  2069.     pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  2070.     GetCategoryHistory(h.guiBuffer);
  2071.     AddHistory(h);
  2072.     /* mini_tab_bar */
  2073. #ifdef __MMI_WGUI_MINI_TAB_BAR__
  2074.     wgui_disable_mini_tab_bar();
  2075. #endif 
  2076. }
  2079. /*****************************************************************************
  2080.  * FUNCTION
  2081.  *  GetExitScrnID
  2082.  * DESCRIPTION
  2083.  *  
  2084.  * PARAMETERS
  2085.  *  void
  2086.  * RETURNS
  2087.  *  
  2088.  *****************************************************************************/
  2089. U16 GetExitScrnID(void)
  2090. {
  2091.     /*----------------------------------------------------------------*/
  2092.     /* Local Variables                                                */
  2093.     /*----------------------------------------------------------------*/
  2095.     /*----------------------------------------------------------------*/
  2096.     /* Code Body                                                      */
  2097.     /*----------------------------------------------------------------*/
  2098.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_GETGEN_EXIT_HDLR));
  2100.     return currExitScrnID;
  2101. }
  2104. /*****************************************************************************
  2105.  * FUNCTION
  2106.  *  GetExitScrnID_r
  2107.  * DESCRIPTION
  2108.  *  Thead-safe version of GetExitScrnID()
  2109.  * PARAMETERS
  2110.  *  void
  2111.  * RETURNS
  2112.  *  Current screen ID
  2113.  *****************************************************************************/
  2114. U16 GetExitScrnID_r(void)
  2115. {
  2116.     /*----------------------------------------------------------------*/
  2117.     /* Local Variables                                                */
  2118.     /*----------------------------------------------------------------*/
  2120.     /*----------------------------------------------------------------*/
  2121.     /* Code Body                                                      */
  2122.     /*----------------------------------------------------------------*/
  2124.     /* This function should be kept as simple as possible. MMI_TRACE() cannot be used */
  2125.     return currExitScrnID;
  2126. }
  2129. /*****************************************************************************
  2130.  * FUNCTION
  2131.  *  ClearExitHandler
  2132.  * DESCRIPTION
  2133.  *  clears current screen exit handlers
  2134.  *  
  2135.  *  This is used to clears current screen exit handlers
  2136.  * PARAMETERS
  2137.  *  void
  2138.  * RETURNS
  2139.  *  void
  2140.  *****************************************************************************/
  2141. void ClearExitHandler(void)
  2142. {
  2143.     /*----------------------------------------------------------------*/
  2144.     /* Local Variables                                                */
  2145.     /*----------------------------------------------------------------*/
  2147.     /*----------------------------------------------------------------*/
  2148.     /* Code Body                                                      */
  2149.     /*----------------------------------------------------------------*/
  2150.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLREXIT_HDLR));
  2151.     currExitScrnID = 0;
  2152.     currExitFuncPtr = NULL;
  2153.     currEntryFuncPtr = NULL;
  2155. }
  2158. /*****************************************************************************
  2159.  * FUNCTION
  2160.  *  GetkeyInfo
  2161.  * DESCRIPTION
  2162.  *  gives key code & key type of last key event.
  2163.  *  
  2164.  *  This is used to give key code & key type of last key event.
  2165.  * PARAMETERS
  2166.  *  keyCode     [OUT]       U16 *keyType
  2167.  *  keyType     [IN]        
  2168.  * RETURNS
  2169.  *  void
  2170.  *****************************************************************************/
  2171. void GetkeyInfo(PU16 keyCode, PU16 keyType)
  2172. {
  2173.     /*----------------------------------------------------------------*/
  2174.     /* Local Variables                                                */
  2175.     /*----------------------------------------------------------------*/
  2177.     /*----------------------------------------------------------------*/
  2178.     /* Code Body                                                      */
  2179.     /*----------------------------------------------------------------*/
  2180.     *keyCode = currKeyCode;
  2181.     *keyType = currKeyType;
  2182. }
  2185. /*****************************************************************************
  2186.  * FUNCTION
  2187.  *  SetkeyInfo
  2188.  * DESCRIPTION
  2189.  *  Set key code & key type of last key event.
  2190.  *  
  2191.  *  This is used to temporary set key code & key type of last key event.
  2192.  * PARAMETERS
  2193.  *  keyCode     [IN]        
  2194.  *  keyType     [IN]        
  2195.  * RETURNS
  2196.  *  void
  2197.  *****************************************************************************/
  2198. void SetkeyInfo(U16 keyCode, U16 keyType)
  2199. {
  2200.     /*----------------------------------------------------------------*/
  2201.     /* Local Variables                                                */
  2202.     /*----------------------------------------------------------------*/
  2204.     /*----------------------------------------------------------------*/
  2205.     /* Code Body                                                      */
  2206.     /*----------------------------------------------------------------*/
  2207.     currKeyCode = keyCode;
  2208.     currKeyType = keyType;
  2209. }
  2212. /*****************************************************************************
  2213.  * FUNCTION
  2214.  *  StartTimer
  2215.  * DESCRIPTION
  2216.  *  to set a timer
  2217.  *  
  2218.  *  This is used to set a timer
  2219.  * PARAMETERS
  2220.  *  timerid     [IN]        
  2221.  *  delay       [IN]        
  2222.  *  funcPtr     [IN]        
  2223.  * RETURNS
  2224.  *  void
  2225.  *****************************************************************************/
  2226. void StartTimer(U16 timerid, U32 delay, FuncPtr funcPtr)
  2227. {
  2228.     /*----------------------------------------------------------------*/
  2229.     /* Local Variables                                                */
  2230.     /*----------------------------------------------------------------*/
  2232.     /*----------------------------------------------------------------*/
  2233.     /* Code Body                                                      */
  2234.     /*----------------------------------------------------------------*/
  2235.     StartMyTimer(timerid, delay, (oslTimerFuncPtr) funcPtr);
  2236. }
  2239. /*****************************************************************************
  2240.  * FUNCTION
  2241.  *  StopTimer
  2242.  * DESCRIPTION
  2243.  *  to reset a timer
  2244.  *  
  2245.  *  This is used to reset a timer
  2246.  * PARAMETERS
  2247.  *  timerid     [IN]        
  2248.  * RETURNS
  2249.  *  void
  2250.  *****************************************************************************/
  2251. void StopTimer(U16 timerid)
  2252. {
  2253.     /*----------------------------------------------------------------*/
  2254.     /* Local Variables                                                */
  2255.     /*----------------------------------------------------------------*/
  2257.     /*----------------------------------------------------------------*/
  2258.     /* Code Body                                                      */
  2259.     /*----------------------------------------------------------------*/
  2260.     StopMyTimer(timerid);
  2261. }
  2264. /*****************************************************************************
  2265.  * FUNCTION
  2266.  *  MaskItems
  2267.  * DESCRIPTION
  2268.  *  
  2269.  * PARAMETERS
  2270.  *  maskList        [IN]        
  2271.  *  noOfItems       [IN]        
  2272.  *  maskingWord     [IN]        
  2273.  * RETURNS
  2274.  *  U8
  2275.  *****************************************************************************/
  2276. U8 MaskItems(U16 *maskList, U8 noOfItems, U32 maskingWord)
  2277. {
  2278.     /*----------------------------------------------------------------*/
  2279.     /* Local Variables                                                */
  2280.     /*----------------------------------------------------------------*/
  2281.     U32 count = 0, i;
  2283.     /*----------------------------------------------------------------*/
  2284.     /* Code Body                                                      */
  2285.     /*----------------------------------------------------------------*/
  2286.     for (i = 0; i < noOfItems; i++)
  2287.         if (IsBitSet(maskingWord, i))
  2288.         {
  2289.             maskList[count++] = maskList[i];
  2290.         }
  2291.     return (U8) count;
  2292. }
  2295. /*****************************************************************************
  2296.  * FUNCTION
  2297.  *  MaskItemsU8
  2298.  * DESCRIPTION
  2299.  *  
  2300.  * PARAMETERS
  2301.  *  maskList        [IN]        
  2302.  *  noOfItems       [IN]        
  2303.  *  maskingWord     [IN]        
  2304.  * RETURNS
  2305.  *  U8
  2306.  *****************************************************************************/
  2307. U8 MaskItemsU8(U8 *maskList, U8 noOfItems, U32 maskingWord)
  2308. {
  2309.     /*----------------------------------------------------------------*/
  2310.     /* Local Variables                                                */
  2311.     /*----------------------------------------------------------------*/
  2312.     U32 count = 0, i;
  2314.     /*----------------------------------------------------------------*/
  2315.     /* Code Body                                                      */
  2316.     /*----------------------------------------------------------------*/
  2317.     for (i = 0; i < noOfItems; i++)
  2318.         if (IsBitSet(maskingWord, i))
  2319.         {
  2320.             maskList[count++] = maskList[i];
  2321.         }
  2322.     return (U8) count;
  2323. }
  2326. /*****************************************************************************
  2327.  * FUNCTION
  2328.  *  MaskStringItems
  2329.  * DESCRIPTION
  2330.  *  
  2331.  * PARAMETERS
  2332.  *  maskList        [IN]        
  2333.  *  noOfItems       [IN]        
  2334.  *  maskingWord     [IN]        
  2335.  * RETURNS
  2336.  *  U8
  2337.  *****************************************************************************/
  2338. U8 MaskStringItems(U8 **maskList, U8 noOfItems, U32 maskingWord)
  2339. {
  2340.     /*----------------------------------------------------------------*/
  2341.     /* Local Variables                                                */
  2342.     /*----------------------------------------------------------------*/
  2343.     U32 count = 0, i;
  2345.     /*----------------------------------------------------------------*/
  2346.     /* Code Body                                                      */
  2347.     /*----------------------------------------------------------------*/
  2348.     for (i = 0; i < noOfItems; i++)
  2349.         if (IsBitSet(maskingWord, i))
  2350.         {
  2351.             maskList[count++] = maskList[i];
  2352.         }
  2353.     return (U8) count;
  2354. }
  2357. /*****************************************************************************
  2358.  * FUNCTION
  2359.  *  MaskHiliteItems
  2360.  * DESCRIPTION
  2361.  *  
  2362.  * PARAMETERS
  2363.  *  parentID        [IN]        
  2364.  *  maskingWord     [IN]        
  2365.  * RETURNS
  2366.  *  U8
  2367.  *****************************************************************************/
  2368. U8 MaskHiliteItems(U16 parentID, U32 maskingWord)
  2369. {
  2370.     /*----------------------------------------------------------------*/
  2371.     /* Local Variables                                                */
  2372.     /*----------------------------------------------------------------*/
  2373.     U8 count = 0, noOfChild, i;
  2374.     U16 hiliteItemID[32];
  2376.     /*----------------------------------------------------------------*/
  2377.     /* Code Body                                                      */
  2378.     /*----------------------------------------------------------------*/
  2379.     noOfChild = (U8) GetNumOfChild(parentID);
  2380.     for (i = 0; i < noOfChild; i++)
  2381.     {
  2382.         hiliteItemID[i] = GetSeqItemId((U16) parentID, (S16) i);
  2383.     }
  2384.     for (i = 0; i < noOfChild; i++)
  2385.         if (IsBitSet(maskingWord, i))
  2386.         {
  2387.             maxHiliteInfo[hiliteItemID[count++]].entryFuncPtr = maxHiliteInfo[hiliteItemID[i]].entryFuncPtr;
  2388.         }
  2389.     return (U8) count;
  2390. }
  2392. /* interrupt handle preprocess */
  2395. /*****************************************************************************
  2396.  * FUNCTION
  2397.  *  IsInInterruptGroupTable
  2398.  * DESCRIPTION
  2399.  *  search interrupt group event id is in interrupt
  2400.  *  group table and get the index
  2401.  * PARAMETERS
  2402.  *  eventID     [IN]        
  2403.  *  index       [OUT]       
  2404.  * RETURNS
  2405.  *  MMI_BOOL
  2406.  *****************************************************************************/
  2407. static MMI_BOOL IsInInterruptGroupTable(U16 eventID, int *index)
  2408. {
  2409.     /*----------------------------------------------------------------*/
  2410.     /* Local Variables                                                */
  2411.     /*----------------------------------------------------------------*/
  2412.     int i;
  2414.     /*----------------------------------------------------------------*/
  2415.     /* Code Body                                                      */
  2416.     /*----------------------------------------------------------------*/
  2417.     for (i = 0; i < sizeof(interruptGroupEventTable) / sizeof(InterruptGroupInfo); i++)
  2418.     {
  2419.         if (interruptGroupEventTable[i].groupID == eventID)
  2420.         {
  2421.             *index = i;
  2422.             return MMI_TRUE;
  2423.         }
  2424.     }
  2426.     *index = -1;
  2427.     return MMI_FALSE;
  2428. }
  2431. /*****************************************************************************
  2432.  * FUNCTION
  2433.  *  QueryInterruptHandler
  2434.  * DESCRIPTION
  2435.  *  query interrupt event handler
  2436.  * PARAMETERS
  2437.  *  eventID         [IN]        
  2438.  *  funcPtr         [OUT]       
  2439.  *  postfuncPtr     [OUT]         
  2440.  * RETURNS
  2441.  *  MMI_BOOL
  2442.  *****************************************************************************/
  2443. static MMI_BOOL QueryInterruptHandler(U16 eventID, PsIntFuncPtr *funcPtr, PsIntFuncPtr *postfuncPtr)
  2444. {
  2445.     /*----------------------------------------------------------------*/
  2446.     /* Local Variables                                                */
  2447.     /*----------------------------------------------------------------*/
  2448.     int i, j, index;
  2450.     /*----------------------------------------------------------------*/
  2451.     /* Code Body                                                      */
  2452.     /*----------------------------------------------------------------*/
  2453.     for (i = 0; i < MAX_INTERRUPT_EVENT; i++)
  2454.     {
  2455.         if (!IS_INTERRUPT_EVENT_GROUP(interruptEventHandler[i].eventID))
  2456.         {
  2457.             /* General interrupt event */
  2458.             if (interruptEventHandler[i].eventID == eventID)
  2459.             {
  2460.                 goto is_found;
  2461.             }
  2462.         }
  2463.         else
  2464.         {
  2465.             if (IsInInterruptGroupTable(interruptEventHandler[i].eventID, &index))
  2466.             {
  2467.                 /* Interrupt group event */
  2468.                 j = 0;
  2469.                 while (interruptGroupEventTable[index].eventID[j] != 0)
  2470.                 {
  2471.                     if (interruptGroupEventTable[index].eventID[j] == eventID)
  2472.                     {
  2473.                         goto is_found;
  2474.                     }
  2475.                     j++;
  2477.                     MMI_ASSERT(j < INTERRUPT_EVENT_GREOUP_SIZE);
  2478.                 }
  2479.             }
  2480.         }
  2482.     }
  2483.     return MMI_FALSE;
  2485.   is_found:
  2486.     *funcPtr = (PsIntFuncPtr) interruptEventHandler[i].entryIntFuncPtr;
  2487.     *postfuncPtr = (PsIntFuncPtr) interruptEventHandler[i].postIntFuncPtr;
  2488.     return MMI_TRUE;
  2490. }
  2493. /*****************************************************************************
  2494.  * FUNCTION
  2495.  *  SetInterruptEventHandler
  2496.  * DESCRIPTION
  2497.  *  sets interrupt event handler
  2498.  *  
  2499.  *  This is used to set interrupt event handler
  2500.  * PARAMETERS
  2501.  *  funcPtr         [IN]        
  2502.  *  postfuncPtr     [IN]        
  2503.  *  eventID         [IN]        
  2504.  * RETURNS
  2505.  *  void
  2506.  *****************************************************************************/
  2507. void SetInterruptEventHandler(PsIntFuncPtr funcPtr, PsIntFuncPtr postfuncPtr, U16 eventID)
  2508. {
  2509.     /*----------------------------------------------------------------*/
  2510.     /* Local Variables                                                */
  2511.     /*----------------------------------------------------------------*/
  2512.     S16 count = 0;
  2513.     pBOOL isNewEvent = TRUE;
  2515.     /*----------------------------------------------------------------*/
  2516.     /* Code Body                                                      */
  2517.     /*----------------------------------------------------------------*/
  2518.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETINTP_HDLR, eventID));
  2520.     if (!IS_INTERRUPT_EVENT_GROUP(eventID))
  2521.     {
  2522.         /* General interrupt event will allocate from the begin */
  2523.         for (count = 0; count < maxInterruptEvent; count++)
  2524.         {
  2525.             if (interruptEventHandler[count].eventID == eventID)
  2526.             {
  2527.                 isNewEvent = FALSE;
  2528.                 break;
  2529.             }
  2530.             if (interruptEventHandler[count].eventID == 0)
  2531.             {
  2532.                 break;
  2533.             }
  2534.         }
  2535.     }
  2536.     else
  2537.     {
  2538.         /* Interrupt group event will allocate from the end */
  2539.         for (count = MAX_INTERRUPT_EVENT - 1; count >= 0; count--)
  2540.         {
  2541.             if (interruptEventHandler[count].eventID == eventID)
  2542.             {
  2543.                 isNewEvent = FALSE;
  2544.                 break;
  2545.             }
  2546.             if (interruptEventHandler[count].eventID == 0)
  2547.             {
  2548.                 break;
  2549.             }
  2550.         }
  2551.     }
  2553.     if (isNewEvent)
  2554.     {
  2555.         maxInterruptEvent++;
  2556.         MMI_ASSERT(maxInterruptEvent < MAX_INTERRUPT_EVENT);
  2557.     }
  2559.     interruptEventHandler[count].eventID = eventID;
  2560.     interruptEventHandler[count].entryIntFuncPtr = funcPtr;
  2561.     interruptEventHandler[count].postIntFuncPtr = postfuncPtr;
  2562. }
  2565. /*****************************************************************************
  2566.  * FUNCTION
  2567.  *  SetGroupInterruptEventHandler
  2568.  * DESCRIPTION
  2569.  *  sets the curent screen same group handler to the group pf events
  2570.  *  
  2571.  *  This is used to set the same key handler for a group of keycodes.
  2572.  * PARAMETERS
  2573.  *  funcPtr         [IN]        
  2574.  *  postfuncPtr     [IN]        
  2575.  *  eventsID        [IN]        
  2576.  *  len             [IN]        
  2577.  * RETURNS
  2578.  *  void
  2579.  *****************************************************************************/
  2580. void SetGroupInterruptEventHandler(PsIntFuncPtr funcPtr, PsIntFuncPtr postfuncPtr, PU16 eventsID, U8 len)
  2581. {
  2582.     /*----------------------------------------------------------------*/
  2583.     /* Local Variables                                                */
  2584.     /*----------------------------------------------------------------*/
  2585.     U8 count;
  2587.     /*----------------------------------------------------------------*/
  2588.     /* Code Body                                                      */
  2589.     /*----------------------------------------------------------------*/
  2590.     for (count = 0; count < len; count++)
  2591.     {
  2592.         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_SETGRPINTP_HDLR, eventsID[count]));
  2593.         SetInterruptEventHandler(funcPtr, postfuncPtr, eventsID[count]);
  2594.     }
  2595. }
  2598. /*****************************************************************************
  2599.  * FUNCTION
  2600.  *  ClearInterruptEventHandler
  2601.  * DESCRIPTION
  2602.  *  clears interrupt event handler
  2603.  *  
  2604.  *  This is used to clear interrupt event handler
  2605.  * PARAMETERS
  2606.  *  eventID     [IN]        
  2607.  * RETURNS
  2608.  *  void
  2609.  *****************************************************************************/
  2610. void ClearInterruptEventHandler(U16 eventID)
  2611. {
  2612.     /*----------------------------------------------------------------*/
  2613.     /* Local Variables                                                */
  2614.     /*----------------------------------------------------------------*/
  2616.     /*----------------------------------------------------------------*/
  2617.     /* Code Body                                                      */
  2618.     /*----------------------------------------------------------------*/
  2619.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRINTP_HDLR, eventID));
  2620.     SetInterruptEventHandler(NULL, NULL, eventID);
  2621. }
  2624. /*****************************************************************************
  2625.  * FUNCTION
  2626.  *  ClearAllInterruptEventHandler
  2627.  * DESCRIPTION
  2628.  *  clears all the interrupt event handler
  2629.  *  
  2630.  *  This is used to clear all the interrupt event handlers
  2631.  * PARAMETERS
  2632.  *  void
  2633.  * RETURNS
  2634.  *  void
  2635.  *****************************************************************************/
  2636. void ClearAllInterruptEventHandler(void)
  2637. {
  2638.     /*----------------------------------------------------------------*/
  2639.     /* Local Variables                                                */
  2640.     /*----------------------------------------------------------------*/
  2641.     U16 count = 0;
  2643.     /*----------------------------------------------------------------*/
  2644.     /* Code Body                                                      */
  2645.     /*----------------------------------------------------------------*/
  2646.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_EVENT_CLRALLINTP_HDLR));
  2648.     for (count = 0; count < maxInterruptEvent; count++)
  2649.     {
  2650.         interruptEventHandler[count].eventID = 0;
  2651.         interruptEventHandler[count].entryIntFuncPtr = NULL;
  2652.         interruptEventHandler[count].postIntFuncPtr = NULL;
  2653.     }
  2654.     maxInterruptEvent = 0;
  2656. }
  2659. /*****************************************************************************
  2660.  * FUNCTION
  2661.  *  GetActiveScreenId
  2662.  * DESCRIPTION
  2663.  *  Get current new screen ID
  2664.  *  
  2665.  *  This is used to clear all the interrupt event handlers
  2666.  * PARAMETERS
  2667.  *  void
  2668.  * RETURNS
  2669.  *  void
  2670.  *****************************************************************************/
  2671. U16 GetActiveScreenId(void)
  2672. {
  2673.     /*----------------------------------------------------------------*/
  2674.     /* Local Variables                                                */
  2675.     /*----------------------------------------------------------------*/
  2677.     /*----------------------------------------------------------------*/
  2678.     /* Code Body                                                      */
  2679.     /*----------------------------------------------------------------*/
  2680.     return currTopScrnID;
  2681. }
  2684. /*****************************************************************************
  2685.  * FUNCTION
  2686.  *  SetActiveScreenId
  2687.  * DESCRIPTION
  2688.  *  
  2689.  * PARAMETERS
  2690.  *  scrnId      [IN]        
  2691.  * RETURNS
  2692.  *  void
  2693.  *****************************************************************************/
  2694. void SetActiveScreenId(U16 scrnId)
  2695. {
  2696.     /*----------------------------------------------------------------*/
  2697.     /* Local Variables                                                */
  2698.     /*----------------------------------------------------------------*/
  2700.     /*----------------------------------------------------------------*/
  2701.     /* Code Body                                                      */
  2702.     /*----------------------------------------------------------------*/
  2703.     currTopScrnID = scrnId;
  2704. }
  2707. /*****************************************************************************
  2708.  * FUNCTION
  2709.  *  GetCurrEntryFuncPtr
  2710.  * DESCRIPTION
  2711.  *  Get current entry function
  2712.  * PARAMETERS
  2713.  *  void
  2714.  * RETURNS
  2715.  *  void
  2716.  *****************************************************************************/
  2717. FuncPtr GetCurrEntryFuncPtr(void)
  2718. {
  2719.     /*----------------------------------------------------------------*/
  2720.     /* Local Variables                                                */
  2721.     /*----------------------------------------------------------------*/
  2723.     /*----------------------------------------------------------------*/
  2724.     /* Code Body                                                      */
  2725.     /*----------------------------------------------------------------*/
  2726.     return currEntryFuncPtr;
  2727. }
  2730. /*****************************************************************************
  2731.  * FUNCTION
  2732.  *  SetCurrEntryFuncPtr
  2733.  * DESCRIPTION
  2734.  *  Sets current entry function
  2735.  * PARAMETERS
  2736.  *  ptr     [IN]        
  2737.  * RETURNS
  2738.  *  void
  2739.  *****************************************************************************/
  2740. void SetCurrEntryFuncPtr(FuncPtr ptr)
  2741. {
  2742.     /*----------------------------------------------------------------*/
  2743.     /* Local Variables                                                */
  2744.     /*----------------------------------------------------------------*/
  2746.     /*----------------------------------------------------------------*/
  2747.     /* Code Body                                                      */
  2748.     /*----------------------------------------------------------------*/
  2749.     currEntryFuncPtr = ptr;
  2750. }
  2753. /*****************************************************************************
  2754.  * FUNCTION
  2755.  *  GetCurrExitFuncPtr
  2756.  * DESCRIPTION
  2757.  *  Get current exit function
  2758.  * PARAMETERS
  2759.  *  void
  2760.  * RETURNS
  2761.  *  void
  2762.  *****************************************************************************/
  2763. FuncPtr GetCurrExitFuncPtr(void)
  2764. {
  2765.     /*----------------------------------------------------------------*/
  2766.     /* Local Variables                                                */
  2767.     /*----------------------------------------------------------------*/
  2769.     /*----------------------------------------------------------------*/
  2770.     /* Code Body                                                      */
  2771.     /*----------------------------------------------------------------*/
  2772.     return currExitFuncPtr;
  2773. }
  2776. /*****************************************************************************
  2777.  * FUNCTION
  2778.  *  SetCurrExitFuncPtr
  2779.  * DESCRIPTION
  2780.  *  Sets current exit function
  2781.  * PARAMETERS
  2782.  *  ptr     [IN]        
  2783.  * RETURNS
  2784.  *  void
  2785.  *****************************************************************************/
  2786. void SetCurrExitFuncPtr(FuncPtr ptr)
  2787. {
  2788.     /*----------------------------------------------------------------*/
  2789.     /* Local Variables                                                */
  2790.     /*----------------------------------------------------------------*/
  2792.     /*----------------------------------------------------------------*/
  2793.     /* Code Body                                                      */
  2794.     /*----------------------------------------------------------------*/
  2795.     currExitFuncPtr = ptr;
  2796. }
  2799. /*****************************************************************************
  2800.  * FUNCTION
  2801.  *  ExecuteItemHiliteHandler
  2802.  * DESCRIPTION
  2803.  *  Execute the hilite handler of specified menu item
  2804.  * PARAMETERS
  2805.  *  hiliteItemID        [IN]        
  2806.  * RETURNS
  2807.  *  void
  2808.  *****************************************************************************/
  2809. void ExecuteItemHiliteHandler(U16 hiliteItemID)
  2810. {
  2811.     /*----------------------------------------------------------------*/
  2812.     /* Local Variables                                                */
  2813.     /*----------------------------------------------------------------*/
  2815.     /*----------------------------------------------------------------*/
  2816.     /* Code Body                                                      */
  2817.     /*----------------------------------------------------------------*/
  2818.     if (maxHiliteInfo[hiliteItemID].entryFuncPtr != NULL)
  2819.     {
  2820.         maxHiliteInfo[hiliteItemID].entryFuncPtr();
  2821.     }
  2822. }