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

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

MTK

开发平台：

C/C++

wgui_touch_screen.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  *   wgui_touch_screen.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   wgui-level functions for touch screen.
  49.  *
  50.  * 
  51.  *
  52.  * Author:
  53.  * -------
  54.  * -------
  55.  *
  56.  *============================================================================
  57.  *             HISTORY
  58.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  59.  *------------------------------------------------------------------------------
  60.  * removed!
  61.  *
  62.  * removed!
  63.  * removed!
  64.  * removed!
  65.  *
  66.  * removed!
  67.  * removed!
  68.  * removed!
  69.  *
  70.  * removed!
  71.  * removed!
  72.  * removed!
  73.  *
  74.  * removed!
  75.  * removed!
  76.  * removed!
  77.  *
  78.  * removed!
  79.  * removed!
  80.  * removed!
  81.  *
  82.  * removed!
  83.  * removed!
  84.  * removed!
  85.  *
  86.  * removed!
  87.  * removed!
  88.  * removed!
  89.  *
  90.  * removed!
  91.  * removed!
  92.  * removed!
  93.  *
  94.  * removed!
  95.  * removed!
  96.  * removed!
  97.  *
  98.  * removed!
  99.  * removed!
  100.  * removed!
  101.  *
  102.  * removed!
  103.  * removed!
  104.  * removed!
  105.  *
  106.  * removed!
  107.  * removed!
  108.  * removed!
  109.  *
  110.  * removed!
  111.  * removed!
  112.  * removed!
  113.  *
  114.  * removed!
  115.  * removed!
  116.  * removed!
  117.  *
  118.  * removed!
  119.  * removed!
  120.  * removed!
  121.  *
  122.  * removed!
  123.  * removed!
  124.  * removed!
  125.  *
  126.  * removed!
  127.  * removed!
  128.  * removed!
  129.  *
  130.  * removed!
  131.  * removed!
  132.  * removed!
  133.  *
  134.  * removed!
  135.  * removed!
  136.  * removed!
  137.  *
  138.  * removed!
  139.  * removed!
  140.  * removed!
  141.  *
  142.  *------------------------------------------------------------------------------
  143.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  144.  *============================================================================
  145.  ****************************************************************************/
  147. #include "MMI_features.h"
  149. #if defined(__MMI_TOUCH_SCREEN__)
  151. #include "stdC.h"
  152. #include "PixtelDataTypes.h"
  153. #include "gui_data_types.h"
  154. #include "wgui_softkeys.h"
  156. #include "kal_non_specific_general_types.h"     /* needed for TouchScreenGprot.h */
  157. #include "wgui_touch_screen.h"
  158. #include "TouchScreenGprot.h"   /* for Touch Screen */
  159. #include "gui_buttons.h"
  160. #include "wgui_fixed_menus.h"
  161. #include "gui_asyncdynamic_menus.h"
  162. #include "DebugInitDef.h"
  163. #include "CommonScreens.h"
  164. #include "CustDataRes.h"
  165. #include "gui_custom_menus.h"
  166. #include "gui_calendar.h"
  167. #include "wgui_calendar.h"
  168. #include "wgui_status_icons.h"
  169. #include "wgui_tab_bars.h"
  170. #include "gui_ems.h"
  171. #include "Calculator.h"
  172. #include "wgui_draw_manager.h"
  173. #ifdef __MMI_STOPWATCH__
  174. #include "Stopwatchgexdcl.h"
  175. #include "stopwatchprot.h"
  176. #include "wgui_categories_stopwatch.h"
  177. #endif /* __MMI_STOPWATCH__ */ 
  178. #include "ProfilingEngine.h"
  180. #ifdef __J2ME__
  181. extern void jui_widget_refresh_lcd(S32 x1, S32 y1, S32 x2, S32 y2);
  182. #endif 
  184. /***************************************************************************** 
  185. * Golbal Variable
  186. *****************************************************************************/
  188. /***************************************************************************** 
  189. * Golbal Function
  190. *****************************************************************************/
  191. MMI_BOOL wgui_null_pen_hdlr(mmi_pen_point_struct point);
  192. mmi_pen_handler wgui_category_control_area_pen_handlers[MMI_PEN_EVENT_TYPE_MAX];
  193. mmi_pen_handler wgui_category_control_area2_pen_handlers[MMI_PEN_EVENT_TYPE_MAX];
  194. mmi_pen_handler wgui_image_pen_handlers[DM_MAX_IMAGES][MMI_PEN_EVENT_TYPE_MAX];
  196. /***************************************************************************** 
  197. * Local Variable
  198. *****************************************************************************/
  199. static U16 g_pen_to_control;    /* indicate which control receive pen events */
  201. /* 
  202.  * In draw manager, some controls have more than one elements.
  203.  * We need to know which element is selected 
  204.  */
  205. static U16 g_pen_to_control_index = 0;
  207. /***************************************************************************** 
  208. * Local Function
  209. *****************************************************************************/
  211. /***************************************************************************** 
  212. * Extern Global  Variables
  213. *****************************************************************************/
  214. extern icontext_button MMI_softkeys[];
  215. extern UI_EMS_input_box MMI_EMS_inputbox;
  217. /***************************************************************************** 
  218. * Extern Global  Function
  219. *****************************************************************************/
  220. extern void (*redraw_current_inline_item) (void);
  221. extern void redraw_EMS_inputbox(void);
  224. /*****************************************************************************
  225.  * FUNCTION
  226.  *  wgui_execute_dm_category_control_area_pen_handler
  227.  * DESCRIPTION
  228.  *  Execute category control area pen handlers
  229.  * PARAMETERS
  230.  *  pen_event_type          [IN]        
  231.  *  point                   [IN]        Pen position
  232.  *  key_event_type(?)       [IN]        - KEY_EVENT_DOWN, KEY_EVENT_UP, KEY_LONG_PRESS
  233.  * RETURNS
  234.  *  void
  235.  *****************************************************************************/
  236. static MMI_BOOL wgui_execute_dm_category_control_area_pen_handler(U16 pen_event_type, mmi_pen_point_struct point)
  237. {
  238.     /*----------------------------------------------------------------*/
  239.     /* Local Variables                                                */
  240.     /*----------------------------------------------------------------*/
  242.     /*----------------------------------------------------------------*/
  243.     /* Code Body                                                      */
  244.     /*----------------------------------------------------------------*/
  245.     MMI_ASSERT(pen_event_type < MMI_PEN_EVENT_TYPE_MAX);
  247.     if (wgui_category_control_area_pen_handlers[pen_event_type] != NULL)
  248.     {
  249.         return wgui_category_control_area_pen_handlers[pen_event_type] (point);
  250.     }
  251.     else
  252.     {
  253.         return MMI_FALSE;
  254.     }
  255. }
  258. /*****************************************************************************
  259.  * FUNCTION
  260.  *  wgui_execute_dm_category_control_area2_pen_handler
  261.  * DESCRIPTION
  262.  *  Execute category control area pen handlers
  263.  * PARAMETERS
  264.  *  pen_event_type          [IN]        
  265.  *  point                   [IN]        Pen position
  266.  *  key_event_type(?)       [IN]        - KEY_EVENT_DOWN, KEY_EVENT_UP, KEY_LONG_PRESS
  267.  * RETURNS
  268.  *  void
  269.  *****************************************************************************/
  270. static MMI_BOOL wgui_execute_dm_category_control_area2_pen_handler(U16 pen_event_type, mmi_pen_point_struct point)
  271. {
  272.     /*----------------------------------------------------------------*/
  273.     /* Local Variables                                                */
  274.     /*----------------------------------------------------------------*/
  276.     /*----------------------------------------------------------------*/
  277.     /* Code Body                                                      */
  278.     /*----------------------------------------------------------------*/
  279.     MMI_ASSERT(pen_event_type < MMI_PEN_EVENT_TYPE_MAX);
  281.     if (wgui_category_control_area2_pen_handlers[pen_event_type] != NULL)
  282.     {
  283.         return wgui_category_control_area2_pen_handlers[pen_event_type] (point);
  284.     }
  285.     else
  286.     {
  287.         return MMI_FALSE;
  288.     }
  289. }
  292. /*****************************************************************************
  293.  * FUNCTION
  294.  *  wgui_execute_dm_image_pen_handler
  295.  * DESCRIPTION
  296.  *  Execute category control area pen handlers
  297.  * PARAMETERS
  298.  *  img_idx                 [IN]        Index of image controlled by draw manager
  299.  *  pen_event_type          [IN]        
  300.  *  point                   [IN]        Pen position
  301.  *  key_event_type(?)       [IN]        - KEY_EVENT_DOWN, KEY_EVENT_UP, KEY_LONG_PRESS
  302.  * RETURNS
  303.  *  void
  304.  *****************************************************************************/
  305. static MMI_BOOL wgui_execute_dm_image_pen_handler(U16 img_idx, U16 pen_event_type, mmi_pen_point_struct point)
  306. {
  307.     /*----------------------------------------------------------------*/
  308.     /* Local Variables                                                */
  309.     /*----------------------------------------------------------------*/
  311.     /*----------------------------------------------------------------*/
  312.     /* Code Body                                                      */
  313.     /*----------------------------------------------------------------*/
  314.     MMI_ASSERT(img_idx < dm_get_image_count());
  315.     MMI_ASSERT(pen_event_type < MMI_PEN_EVENT_TYPE_MAX);
  317.     if (wgui_image_pen_handlers[img_idx][pen_event_type] != NULL)
  318.     {
  319.         return wgui_image_pen_handlers[img_idx][pen_event_type] (point);
  320.     }
  321.     else
  322.     {
  323.         return MMI_FALSE;
  324.     }
  325. }
  328. /*****************************************************************************
  329.  * FUNCTION
  330.  *  wgui_pen_execute_LSK_handler
  331.  * DESCRIPTION
  332.  *  Execute left softkey handler from pen
  333.  * PARAMETERS
  334.  *  key_type        [IN]        - KEY_EVENT_DOWN, KEY_EVENT_UP, KEY_LONG_PRESS
  335.  * RETURNS
  336.  *  void
  337.  *****************************************************************************/
  338. static void wgui_pen_execute_LSK_handler(U16 key_type)
  339. {
  340.     /*----------------------------------------------------------------*/
  341.     /* Local Variables                                                */
  342.     /*----------------------------------------------------------------*/
  344.     /*----------------------------------------------------------------*/
  345.     /* Code Body                                                      */
  346.     /*----------------------------------------------------------------*/
  347.     /* In MMI convention, applications typically clear key handlers before sending requests to other tasks, 
  348.        which avoid re-entrance of protocol handler */
  350.     if (GetKeyHandler(KEY_LSK, key_type))
  351.     {
  352.         /* Some softkey handlers use GetkeyInfo() */
  353.         SetkeyInfo(KEY_LSK, key_type);
  354.         execute_softkey_function(key_type, MMI_LEFT_SOFTKEY);
  355.     }
  356. }
  359. /*****************************************************************************
  360.  * FUNCTION
  361.  *  wgui_pen_execute_RSK_handler
  362.  * DESCRIPTION
  363.  *  Execute right softkey handler from pen
  364.  * PARAMETERS
  365.  *  key_type        [IN]        
  366.  * RETURNS
  367.  *  void
  368.  *****************************************************************************/
  369. static void wgui_pen_execute_RSK_handler(U16 key_type)
  370. {
  371.     /*----------------------------------------------------------------*/
  372.     /* Local Variables                                                */
  373.     /*----------------------------------------------------------------*/
  375.     /*----------------------------------------------------------------*/
  376.     /* Code Body                                                      */
  377.     /*----------------------------------------------------------------*/
  378.     /* In MMI convention, applications typically clear key handlers before sending requests to other tasks, 
  379.        which avoid re-entrance of protocol handler */
  381.     if (GetKeyHandler(KEY_RSK, key_type))
  382.     {
  383.         /* Some softkey handlers use GetkeyInfo() */
  384.         SetkeyInfo(KEY_RSK, key_type);
  385.         execute_softkey_function(key_type, MMI_RIGHT_SOFTKEY);
  386.     }
  387. }
  389. #ifdef __MMI_WGUI_CSK_ENABLE__
  392. /*****************************************************************************
  393.  * FUNCTION
  394.  *  wgui_pen_execute_CSK_handler
  395.  * DESCRIPTION
  396.  *  Execute center softkey handler from pen
  397.  * PARAMETERS
  398.  *  key_type        [IN]        
  399.  * RETURNS
  400.  *  void
  401.  *****************************************************************************/
  402. static void wgui_pen_execute_CSK_handler(U16 key_type)
  403. {
  404.     /*----------------------------------------------------------------*/
  405.     /* Local Variables                                                */
  406.     /*----------------------------------------------------------------*/
  408.     /*----------------------------------------------------------------*/
  409.     /* Code Body                                                      */
  410.     /*----------------------------------------------------------------*/
  411.     /* In MMI convention, applications typically clear key handlers before sending requests to other tasks, 
  412.        which avoid re-entrance of protocol handler */
  414.     if (GetKeyHandler(KEY_CSK, key_type))
  415.     {
  416.         /* Some softkey handlers use GetkeyInfo() */
  417.         SetkeyInfo(KEY_CSK, key_type);
  418.         execute_softkey_function(key_type, MMI_CENTER_SOFTKEY);
  419.     }
  420. }
  421. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  424. /*****************************************************************************
  425.  * FUNCTION
  426.  *  wgui_pen_redraw_inline_editor
  427.  * DESCRIPTION
  428.  *  Redraw inline editor
  429.  * PARAMETERS
  430.  *  void
  431.  * RETURNS
  432.  *  void
  433.  *****************************************************************************/
  434. static void wgui_pen_redraw_inline_editor(void)
  435. {
  436.     /*----------------------------------------------------------------*/
  437.     /* Local Variables                                                */
  438.     /*----------------------------------------------------------------*/
  440.     /*----------------------------------------------------------------*/
  441.     /* Code Body                                                      */
  442.     /*----------------------------------------------------------------*/
  443.     redraw_fixed_list();
  444.     redraw_current_inline_item();
  445. }
  448. /*****************************************************************************
  449.  * FUNCTION
  450.  *  wgui_general_pen_down_hdlr
  451.  * DESCRIPTION
  452.  *  General Pen Down event handler.
  453.  * PARAMETERS
  454.  *  point       [IN]        
  455.  * RETURNS
  456.  *  void
  457.  *****************************************************************************/
  458. void wgui_general_pen_down_hdlr(mmi_pen_point_struct point)
  459. {
  460.     /*----------------------------------------------------------------*/
  461.     /* Local Variables                                                */
  462.     /*----------------------------------------------------------------*/
  463.     S32 u8CtrlCt = 0;
  464.     S32 u8NoOfUICtrls = 0;
  465.     S16 *UICtrlAccessPtr_p = NULL, *DeafultCoordinateSet_p = NULL;
  466.     dm_cat_scr_info_struct dm_cat_scr_info;
  467.     S32 idx = 0;
  468.     U8 *control_set_ptr = NULL;
  469.     BOOL ret;
  470.     gui_button_pen_enum button_event;
  471.     gui_list_pen_enum menu_event;
  472.     gui_matrix_pen_enum matrix_event;
  473.     gui_inline_pen_enum inline_event;
  474.     gui_slide_control_pen_event_enum slide_event;
  475.     gui_pen_event_param_struct param;
  476.     gui_3D_circular_menu_pen_enum circular_event;
  477.     gui_calendar_pen_enum calendar_event;
  478.     wgui_status_icon_bar_pen_enum status_icon_bar_event;
  479.     S16 status_icon_id;
  480.     gui_multi_line_input_box_pen_enum multi_line_input_box_event;
  481.     gui_EMS_input_box_pen_enum EMS_input_box_event;
  482.     S16 dm_image_index = -1;
  483.     S16 dm_button_index = -1;
  485.     /*----------------------------------------------------------------*/
  486.     /* Code Body                                                      */
  487.     /*----------------------------------------------------------------*/
  488.     /* to reset dm_data when screen changes */
  489.     if (g_dm_data.s32CatId == 0)
  490.     {
  491.         g_pen_to_control = NONE;
  492.         g_pen_to_control_index = 0;
  493.         return;
  494.     }
  496.     control_set_ptr = dm_search_control_set((U16) g_dm_data.s32CatId, &DeafultCoordinateSet_p);
  498.     /* First element in Category-Controls map specifies the number of controls */
  499.     u8NoOfUICtrls = control_set_ptr[0];
  501.     UICtrlAccessPtr_p = dm_search_coordinate_set(g_dm_data.s32ScrId);
  502.     if (UICtrlAccessPtr_p == NULL)
  503.     {
  504.         UICtrlAccessPtr_p = DeafultCoordinateSet_p;
  505.     }
  507.    /*************************************************************************
  508.    If dm_search_coordinate_set returns NULL, then there must be Default Coordinate Set.
  509.    *************************************************************************/
  510.     MMI_ASSERT(UICtrlAccessPtr_p != NULL);
  512.     /* Fist element in coordinate set specifies the coordinates of complete category screen */
  513.     UICtrlAccessPtr_p = dm_get_cat_scr_coordinates(UICtrlAccessPtr_p, &dm_cat_scr_info);
  515.     /* Start from the toppest components */
  516.     for (u8CtrlCt = u8NoOfUICtrls; u8CtrlCt > 0; u8CtrlCt--)
  517.     {
  518.         switch (control_set_ptr[u8CtrlCt])
  519.         {
  520.             case DM_LIST1:
  521.             case DM_TYPICAL_STOPWATCH:
  522.                 /* redraw_fixed_list */
  523.                 MMI_fixed_list_menu.pen_redraw_menu_function = show_fixed_list;
  524.                 gui_vertical_scrollbar_set_pen_self_scroll(&MMI_fixed_list_menu.vbar, MMI_TRUE);
  525.                 gui_fixed_list_menu_set_pen_scroll_delay(&MMI_fixed_list_menu, 0);
  527.                 ret = gui_fixed_list_menu_translate_pen_event(
  528.                         &MMI_fixed_list_menu,
  529.                         MMI_PEN_EVENT_DOWN,
  530.                         point.x,
  531.                         point.y,
  532.                         &menu_event);
  533.                 if (ret)
  534.                 {
  535.                     g_pen_to_control = DM_LIST1;
  536.                     if (menu_event == GUI_LIST_PEN_HIGHLIGHT_CHANGED || menu_event == GUI_LIST_PEN_NEED_REDRAW)
  537.                     {
  538.                     #ifdef __MMI_INTERACTIVE_PROFILNG__
  539.                         mmi_frm_profiling_delay_start_timer(MMI_FRM_PROFILING_DELAY_LIST_HIGHLIGHT);
  540.                     #endif
  541.                     
  542.                         MMI_fixed_list_menu.pen_redraw_menu_function();
  543.                         
  544.                     #ifdef __MMI_INTERACTIVE_PROFILNG__
  545.                         mmi_frm_profiling_delay_perform(MMI_FRM_PROFILING_DELAY_LIST_HIGHLIGHT);
  546.                     #endif
  547.                     }
  548.                     return;
  549.                 }
  550.                 break;
  552.             case DM_BASE_CONTROL_SET1:
  553.             case DM_BASE_CONTROL_SET2:
  554.             case DM_BUTTON_BAR1:
  555.             case DM_LSK:
  556.             case DM_RSK:
  557.                 if (!(g_dm_data.s32flags & DM_NO_SOFTKEY))
  558.                 {
  559.                     /* LSK */
  560.                     ret = gui_icontext_button_translate_pen_event(
  561.                             &MMI_softkeys[MMI_LEFT_SOFTKEY],
  562.                             MMI_PEN_EVENT_DOWN,
  563.                             point.x,
  564.                             point.y,
  565.                             &button_event);
  567.                     if (ret)
  568.                     {
  569.                         g_pen_to_control = DM_LSK;
  570.                         if (button_event == GUI_BUTTON_PEN_DOWN)
  571.                         {
  572.                             wgui_pen_execute_LSK_handler(KEY_EVENT_DOWN);
  573.                         }
  574.                         return;
  575.                     }
  577.                     /* RSK */
  578.                     ret = gui_icontext_button_translate_pen_event(
  579.                             &MMI_softkeys[MMI_RIGHT_SOFTKEY],
  580.                             MMI_PEN_EVENT_DOWN,
  581.                             point.x,
  582.                             point.y,
  583.                             &button_event);
  585.                     if (ret)
  586.                     {
  587.                         g_pen_to_control = DM_RSK;
  588.                         if (button_event == GUI_BUTTON_PEN_DOWN)
  589.                         {
  590.                             wgui_pen_execute_RSK_handler(KEY_EVENT_DOWN);
  591.                         }
  592.                         return;
  593.                     }
  595.                 #ifdef __MMI_WGUI_CSK_ENABLE__
  596.                     /* CSK */
  597.                     ret = gui_icontext_button_translate_pen_event(
  598.                             &MMI_softkeys[MMI_CENTER_SOFTKEY],
  599.                             MMI_PEN_EVENT_DOWN,
  600.                             point.x,
  601.                             point.y,
  602.                             &button_event);
  604.                     if (ret)
  605.                     {
  606.                         g_pen_to_control = DM_CSK;
  607.                         if (button_event == GUI_BUTTON_PEN_DOWN)
  608.                         {
  609.                             wgui_pen_execute_CSK_handler(KEY_EVENT_DOWN);
  610.                         }
  611.                         return;
  612.                     }
  613.                 #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  614.                 }
  615.                 ret = wgui_status_icon_translate_pen_event(
  616.                         MMI_PEN_EVENT_DOWN,
  617.                         point.x,
  618.                         point.y,
  619.                         &status_icon_id,
  620.                         &status_icon_bar_event);
  621.                 if (ret)
  622.                 {
  623.                     g_pen_to_control = DM_STATUS_BAR1;
  624.                     return;
  625.                 }
  626.                 break;
  628.             case DM_MATRIX_MENU1:
  629.                 ret = gui_fixed_matrix_menu_translate_pen_event(
  630.                         &MMI_fixed_matrix_menu,
  631.                         MMI_PEN_EVENT_DOWN,
  632.                         point.x,
  633.                         point.y,
  634.                         &matrix_event);
  635.                 if (ret)
  636.                 {
  637.                     g_pen_to_control = DM_MATRIX_MENU1;
  638.                     if (matrix_event == GUI_MATRIX_PEN_HIGHLIGHT_CHANGED || matrix_event == GUI_MATRIX_PEN_NEED_REDRAW)
  639.                     {
  640.                     #ifdef __MMI_INTERACTIVE_PROFILNG__
  641.                         mmi_frm_profiling_delay_start_timer(MMI_FRM_PROFILING_DELAY_MATRIX_HIGHLIGHT);
  642.                     #endif
  643.                     
  644.                         show_fixed_matrix();
  645.                         
  646.                     #ifdef __MMI_INTERACTIVE_PROFILNG__
  647.                         mmi_frm_profiling_delay_perform(MMI_FRM_PROFILING_DELAY_MATRIX_HIGHLIGHT);
  648.                     #endif
  649.                     }
  650.                     return;
  651.                 }
  652.                 break;
  654.             case DM_DYNAMIC_LIST1:
  655.                 MMI_fixed_list_menu.pen_redraw_menu_function = show_dynamic_list;
  656.                 gui_vertical_scrollbar_set_pen_self_scroll(&MMI_fixed_list_menu.vbar, MMI_TRUE);
  657.                 gui_fixed_list_menu_set_pen_scroll_delay(&MMI_fixed_list_menu, GUI_DYNAMIC_LIST_PEN_SCROLL_DELAY);
  659.                 ret = gui_dynamic_list_menu_translate_pen_event(
  660.                         &MMI_fixed_list_menu,
  661.                         MMI_PEN_EVENT_DOWN,
  662.                         point.x,
  663.                         point.y,
  664.                         &menu_event);
  665.                 if (ret)
  666.                 {
  667.                     g_pen_to_control = DM_DYNAMIC_LIST1;
  668.                     if (menu_event == GUI_LIST_PEN_HIGHLIGHT_CHANGED || menu_event == GUI_LIST_PEN_NEED_REDRAW)
  669.                     {
  670.                         MMI_fixed_list_menu.pen_redraw_menu_function();
  671.                     }
  672.                     return;
  673.                 }
  674.                 break;
  676.             case DM_ASYNCDYNAMIC_LIST1:
  677.                 MMI_fixed_list_menu.pen_redraw_menu_function = show_asyncdynamic_list;
  678.                 gui_vertical_scrollbar_set_pen_self_scroll(&MMI_fixed_list_menu.vbar, MMI_TRUE);
  679.                 gui_fixed_list_menu_set_pen_scroll_delay(&MMI_fixed_list_menu, GUI_DYNAMIC_LIST_PEN_SCROLL_DELAY);
  681.                 ret = gui_asyncdynamic_list_menu_translate_pen_event(
  682.                         &MMI_fixed_list_menu,
  683.                         MMI_PEN_EVENT_DOWN,
  684.                         point.x,
  685.                         point.y,
  686.                         &menu_event);
  687.                 if (ret)
  688.                 {
  689.                     g_pen_to_control = DM_ASYNCDYNAMIC_LIST1;
  690.                     if (menu_event == GUI_LIST_PEN_HIGHLIGHT_CHANGED || menu_event == GUI_LIST_PEN_NEED_REDRAW)
  691.                     {
  692.                         MMI_fixed_list_menu.pen_redraw_menu_function();
  693.                     }
  694.                     return;
  695.                 }
  696.                 break;
  698.             case DM_INLINE_FIXED_LIST1:
  699.                 MMI_fixed_list_menu.pen_redraw_menu_function = wgui_pen_redraw_inline_editor;
  700.                 /* 
  701.                  * The scroll offset of inline editor might be different than the scroll value of scrollbar
  702.                  * due to the restrictions of inline editor.
  703.                  */
  704.                 gui_vertical_scrollbar_set_pen_self_scroll(&MMI_fixed_list_menu.vbar, MMI_FALSE);
  705.                 gui_fixed_list_menu_set_pen_scroll_delay(&MMI_fixed_list_menu, 0);
  707.                 ret = gui_inline_translate_pen_event(
  708.                         &MMI_fixed_list_menu,
  709.                         MMI_PEN_EVENT_DOWN,
  710.                         point.x,
  711.                         point.y,
  712.                         &inline_event);
  713.                 if (ret)
  714.                 {
  715.                     g_pen_to_control = DM_INLINE_FIXED_LIST1;
  716.                     if (inline_event == GUI_INLINE_PEN_NEED_REDRAW)
  717.                     {
  718.                         MMI_fixed_list_menu.pen_redraw_menu_function();
  719.                     }
  720.                     return;
  721.                 }
  722.                 break;
  724.             case DM_SLIDE_CONTROL:
  725.             {
  726.                 extern S32 dm_slide_control_count;
  728.                 for (idx = 0; idx < dm_slide_control_count; idx++)
  729.                 {
  730.                     ret = wgui_slide_control_translate_pen_event(
  731.                             &MMI_slide_control[idx],
  732.                             MMI_PEN_EVENT_DOWN,
  733.                             point.x,
  734.                             point.y,
  735.                             &slide_event,
  736.                             &param);
  737.                     if (ret)
  738.                     {
  739.                         g_pen_to_control = DM_SLIDE_CONTROL;
  741.                         if (MMI_current_slide_control != &MMI_slide_control[idx])
  742.                         {
  743.                             gui_lock_double_buffer();
  745.                             /* Redraw previous focused slide */
  746.                             wgui_hide_slide_control_focus();
  747.                             wgui_show_slide_control();
  749.                             /* Draw current focused slide */
  750.                             wgui_slide_control_set_focus(&MMI_slide_control[idx]);
  752.                             wgui_show_slide_control_focus();
  753.                             if (slide_event == GUI_SLIDE_CONTROL_PEN_JUMP_TO_I)
  754.                             {
  755.                                 wgui_slide_control_set_value(param._u.i);
  756.                             }
  757.                             else
  758.                             {
  759.                                 wgui_show_slide_control();
  760.                             }
  762.                             gui_unlock_double_buffer();
  763.                             gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  764.                         }
  765.                         else
  766.                         {
  767.                             if (slide_event == GUI_SLIDE_CONTROL_PEN_JUMP_TO_I)
  768.                             {
  769.                                 wgui_show_slide_control_focus();
  770.                                 wgui_slide_control_set_value(param._u.i);
  771.                             }
  772.                         }
  774.                         return;
  775.                     }
  776.                 }
  777.                 break;
  778.             }
  780.             case DM_CALENDAR:
  781.                 ret = wgui_calendar_translate_pen_event(
  782.                         &MMI_calendar_control,
  783.                         MMI_PEN_EVENT_DOWN,
  784.                         point.x,
  785.                         point.y,
  786.                         &calendar_event);
  788.                 if (ret)
  789.                 {
  790.                     g_pen_to_control = DM_CALENDAR;
  791.                     return;
  792.                 }
  793.                 break;
  795.             case DM_CIRCULAR_MENU1:
  796.                 ret = gui_3D_circular_menu_translate_pen_event(
  797.                         &wgui_CM3D_menu,
  798.                         MMI_PEN_EVENT_DOWN,
  799.                         point.x,
  800.                         point.y,
  801.                         &circular_event);
  802.                 if (ret)
  803.                 {
  804.                     g_pen_to_control = DM_CIRCULAR_MENU1;
  805.                     if (circular_event == GUI_3D_CIRCULAR_MENU_PEN_GOTO_NEXT)
  806.                     {
  807.                         circular_3d_menu_next();
  808.                     }
  809.                     else if (circular_event == GUI_3D_CIRCULAR_MENU_PEN_GOTO_PREVIOUS)
  810.                     {
  811.                         circular_3d_menu_previous();
  812.                     }
  813.                     return;
  814.                 }
  815.                 break;
  817.             case DM_HORIZONTAL_TAB_BAR:
  818.                 ret = wgui_general_pen_horizontal_tab_bar_hdlr(point, MMI_PEN_EVENT_DOWN);
  819.                 if (ret)
  820.                 {
  821.                     g_pen_to_control = DM_HORIZONTAL_TAB_BAR;
  822.                     return;
  823.                 }
  825.                 break;
  827.             #ifdef __MMI_STOPWATCH__
  828.             case DM_NWAY_STOPWATCH:
  829.             {
  830.                 S32 index;
  832.                 if (wgui_stopwatch_pen_down_hdlr(point, &index) == MMI_TRUE)
  833.                 {
  834.                     g_pen_to_control = DM_NWAY_STOPWATCH;
  835.                     gStopwatchAppInfo.currentTimerIndex = index;
  836.                     StartIndexTimer();
  837.                     start_multipurpose_list_watch((U8) index);
  838.                 }
  839.             }
  840.                 break;
  841.             #endif /* __MMI_STOPWATCH__ */ 
  842.             case DM_MULTILINE_INPUTBOX1:
  843.             {
  844.                 if (MMI_multiline_inputbox.flags & UI_MULTI_LINE_INPUT_BOX_VIEW_MODE)
  845.                 {
  846.                     ret = gui_multi_line_input_box_translate_pen_event(
  847.                             &MMI_multiline_inputbox,
  848.                             MMI_PEN_EVENT_DOWN,
  849.                             point.x,
  850.                             point.y,
  851.                             &multi_line_input_box_event);
  852.                     if (ret)
  853.                     {
  854.                         g_pen_to_control = DM_MULTILINE_INPUTBOX1;
  855.                         return;
  856.                     }
  857.                 }
  858.             }
  859.                 break;
  860.             case DM_EMS_INPUTBOX1:
  861.             {
  862.                 if (MMI_EMS_inputbox.flags & UI_EMS_INPUT_BOX_VIEW_MODE)
  863.                 {
  864.                     ret = gui_EMS_input_box_translate_pen_event(
  865.                             &MMI_EMS_inputbox,
  866.                             MMI_PEN_EVENT_DOWN,
  867.                             point.x,
  868.                             point.y,
  869.                             &EMS_input_box_event);
  870.                     if (ret)
  871.                     {
  872.                     /*
  873.                     #ifdef __MMI_MESSAGES_EMS__
  874.                         EMS_cancel_object_focus();
  875.                     #endif 
  876.                     */
  877.                         g_pen_to_control = DM_EMS_INPUTBOX1;
  878.                         return;
  879.                     }
  880.                 }
  881.             }
  882.                 break;
  884.             case DM_DIALER_INPUT_BOX1:
  885.             {
  886.                 if (PEN_CHECK_BOUND
  887.                     (point.x, point.y, MMI_dialer_inputbox.x, MMI_dialer_inputbox.y, MMI_dialer_inputbox.width,
  888.                      MMI_dialer_inputbox.height))
  889.                 {
  890.                     g_pen_to_control = DM_DIALER_INPUT_BOX1;
  891.                     gui_show_dialer_input_box_ext(&MMI_dialer_inputbox, point.x, point.y);
  892.                     show_dialer_inputbox();
  893.                     return;
  894.                 }
  895.             }
  896.                 break;
  898.             case DM_IMAGE:
  899.                 /* If there are more than one draw manager object in control set, we only need to scan all image once */
  900.                 if (dm_image_index == -1)   /* first time for DM_IMAGE */
  901.                 {
  902.                     for (dm_image_index = 0; dm_image_index < dm_get_image_count(); dm_image_index++)
  903.                     {
  904.                         if (dm_check_image_bound(dm_image_index, point))
  905.                         {
  906.                             if (wgui_execute_dm_image_pen_handler(dm_image_index, MMI_PEN_EVENT_DOWN, point))
  907.                             {
  908.                                 g_pen_to_control = DM_IMAGE;
  909.                                 g_pen_to_control_index = dm_image_index;
  910.                                 return;
  911.                             }
  912.                         }
  913.                     }
  914.                 }
  915.                 break;
  917.             case DM_BUTTON:
  918.                 if (dm_button_index == -1)  /* first time for DM_BUTTON */
  919.                 {
  920.                     for (dm_button_index = 0; dm_button_index < dm_get_button_count(); dm_button_index++)
  921.                     {
  922.                         ret = gui_icontext_button_translate_pen_event(
  923.                                 dm_get_button(dm_button_index),
  924.                                 MMI_PEN_EVENT_DOWN,
  925.                                 point.x,
  926.                                 point.y,
  927.                                 &button_event);
  929.                         if (ret)
  930.                         {
  931.                             g_pen_to_control = DM_BUTTON;
  932.                             g_pen_to_control_index = dm_button_index;
  933.                             if (button_event == GUI_BUTTON_PEN_DOWN)
  934.                             {
  935.                                 dm_execute_button_handler(dm_button_index, KEY_EVENT_DOWN);
  936.                             }
  937.                             return;
  938.                         }
  939.                     }
  940.                 }
  941.                 break;
  943.             case DM_CATEGORY_CONTROLLED_AREA:
  944.                 if (wgui_execute_dm_category_control_area_pen_handler(KEY_EVENT_DOWN, point) == MMI_TRUE)
  945.                 {
  946.                     g_pen_to_control = DM_CATEGORY_CONTROLLED_AREA;
  947.                     return;
  948.                 }
  949.                 break;
  950.             case DM_CATEGORY_CONTROLLED_AREA2:
  951.                 if (wgui_execute_dm_category_control_area2_pen_handler(KEY_EVENT_DOWN, point) == MMI_TRUE)
  952.                 {
  953.                     g_pen_to_control = DM_CATEGORY_CONTROLLED_AREA2;
  954.                     return;
  955.                 }
  956.                 break;
  957.             default:
  958.                 g_pen_to_control = NONE;
  959.                 break;
  960.         }
  961.     }
  962. }
  965. /*****************************************************************************
  966.  * FUNCTION
  967.  *  wgui_general_pen_move_hdlr
  968.  * DESCRIPTION
  969.  *  General Pen Move event handler.
  970.  * PARAMETERS
  971.  *  point       [IN]        
  972.  * RETURNS
  973.  *  void
  974.  *****************************************************************************/
  975. void wgui_general_pen_move_hdlr(mmi_pen_point_struct point)
  976. {
  977.     /*----------------------------------------------------------------*/
  978.     /* Local Variables                                                */
  979.     /*----------------------------------------------------------------*/
  980.     gui_button_pen_enum button_event;
  981.     gui_multi_line_input_box_pen_enum multi_line_input_box_event;
  982.     gui_EMS_input_box_pen_enum EMS_input_box_event;
  983.     wgui_status_icon_bar_pen_enum status_icon_bar_event;
  984.     S16 status_icon_id;
  986.     /*----------------------------------------------------------------*/
  987.     /* Code Body                                                      */
  988.     /*----------------------------------------------------------------*/
  989.     if (g_pen_to_control == DM_LSK)
  990.     {
  991.         gui_icontext_button_translate_pen_event(
  992.             &MMI_softkeys[MMI_LEFT_SOFTKEY],
  993.             MMI_PEN_EVENT_MOVE,
  994.             point.x,
  995.             point.y,
  996.             &button_event);
  997.     }
  998.     else if (g_pen_to_control == DM_RSK)
  999.     {
  1000.         gui_icontext_button_translate_pen_event(
  1001.             &MMI_softkeys[MMI_RIGHT_SOFTKEY],
  1002.             MMI_PEN_EVENT_MOVE,
  1003.             point.x,
  1004.             point.y,
  1005.             &button_event);
  1006.     }
  1007. #ifdef __MMI_WGUI_CSK_ENABLE__
  1008.     else if (g_pen_to_control == DM_CSK)
  1009.     {
  1010.         gui_icontext_button_translate_pen_event(
  1011.             &MMI_softkeys[MMI_CENTER_SOFTKEY],
  1012.             MMI_PEN_EVENT_MOVE,
  1013.             point.x,
  1014.             point.y,
  1015.             &button_event);
  1016.     }
  1017. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1018.     else if (g_pen_to_control == DM_STATUS_BAR1)
  1019.     {
  1020.         wgui_status_icon_translate_pen_event(
  1021.             MMI_PEN_EVENT_MOVE,
  1022.             point.x,
  1023.             point.y,
  1024.             &status_icon_id,
  1025.             &status_icon_bar_event);
  1027.     }
  1028.     else if (g_pen_to_control == DM_LIST1)
  1029.     {
  1030.         wgui_general_pen_list_menu_hdlr(point, MMI_PEN_EVENT_MOVE);
  1031.     }
  1032.     else if (g_pen_to_control == DM_INLINE_FIXED_LIST1)
  1033.     {
  1034.         wgui_general_pen_inline_hdlr(point, MMI_PEN_EVENT_MOVE);
  1035.     }
  1036.     else if (g_pen_to_control == DM_DYNAMIC_LIST1)
  1037.     {
  1038.         wgui_general_pen_dynamic_list_menu_hdlr(point, MMI_PEN_EVENT_MOVE);
  1039.     }
  1040.     else if (g_pen_to_control == DM_ASYNCDYNAMIC_LIST1)
  1041.     {
  1042.         wgui_general_pen_asyncdynamic_list_menu_hdlr(point, MMI_PEN_EVENT_MOVE);
  1043.     }
  1044.     else if (g_pen_to_control == DM_MATRIX_MENU1)
  1045.     {
  1046.         wgui_general_pen_matrix_menu_hdlr(point, MMI_PEN_EVENT_MOVE);
  1047.     }
  1048.     else if (g_pen_to_control == DM_SLIDE_CONTROL)
  1049.     {
  1050.         wgui_general_pen_slide_control_hdlr(point, MMI_PEN_EVENT_MOVE);
  1051.     }
  1052.     else if (g_pen_to_control == DM_CALENDAR)
  1053.     {
  1054.         wgui_general_pen_calendar_hdlr(point, MMI_PEN_EVENT_MOVE);
  1055.     }
  1056.     else if (g_pen_to_control == DM_CIRCULAR_MENU1)
  1057.     {
  1058.         wgui_general_pen_3D_circular_menu_hdlr(point, MMI_PEN_EVENT_MOVE);
  1059.     }
  1060.     else if (g_pen_to_control == DM_HORIZONTAL_TAB_BAR)
  1061.     {
  1062.         wgui_general_pen_horizontal_tab_bar_hdlr(point, MMI_PEN_EVENT_MOVE);
  1063.     }
  1064.     else if (g_pen_to_control == DM_MULTILINE_INPUTBOX1)
  1065.     {
  1066.         gui_multi_line_input_box_translate_pen_event(
  1067.             &MMI_multiline_inputbox,
  1068.             MMI_PEN_EVENT_MOVE,
  1069.             point.x,
  1070.             point.y,
  1071.             &multi_line_input_box_event);
  1072.     }
  1073.     else if (g_pen_to_control == DM_EMS_INPUTBOX1)
  1074.     {
  1075.         gui_EMS_input_box_translate_pen_event(
  1076.             &MMI_EMS_inputbox,
  1077.             MMI_PEN_EVENT_MOVE,
  1078.             point.x,
  1079.             point.y,
  1080.             &EMS_input_box_event);
  1081.     }
  1082.     else if (g_pen_to_control == DM_TYPICAL_STOPWATCH)
  1083.     {
  1084.         wgui_general_pen_list_menu_hdlr(point, MMI_PEN_EVENT_MOVE);
  1085.     }
  1086.     else if (g_pen_to_control == DM_DIALER_INPUT_BOX1)
  1087.     {
  1088.         if (PEN_CHECK_BOUND
  1089.             (point.x, point.y, MMI_dialer_inputbox.x, MMI_dialer_inputbox.y, MMI_dialer_inputbox.width,
  1090.              MMI_dialer_inputbox.height))
  1091.         {
  1092.             g_pen_to_control = DM_DIALER_INPUT_BOX1;
  1093.             gui_show_dialer_input_box_ext(&MMI_dialer_inputbox, point.x, point.y);
  1094.             show_dialer_inputbox();
  1095.             return;
  1096.         }
  1097.     }
  1098.     else if (g_pen_to_control == DM_BUTTON)
  1099.     {
  1100.         gui_icontext_button_translate_pen_event(
  1101.             dm_get_button(g_pen_to_control_index),
  1102.             MMI_PEN_EVENT_MOVE,
  1103.             point.x,
  1104.             point.y,
  1105.             &button_event);
  1106.     }
  1107.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA)
  1108.     {
  1109.         wgui_execute_dm_category_control_area_pen_handler(MMI_PEN_EVENT_MOVE, point);
  1110.     }
  1111.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA2)
  1112.     {
  1113.         wgui_execute_dm_category_control_area2_pen_handler(MMI_PEN_EVENT_MOVE, point);
  1114.     }
  1115. }
  1118. /*****************************************************************************
  1119.  * FUNCTION
  1120.  *  wgui_general_pen_up_hdlr
  1121.  * DESCRIPTION
  1122.  *  General Pen Up event handler.
  1123.  * PARAMETERS
  1124.  *  point       [IN]        
  1125.  * RETURNS
  1126.  *  void
  1127.  *****************************************************************************/
  1128. void wgui_general_pen_up_hdlr(mmi_pen_point_struct point)
  1129. {
  1130.     /*----------------------------------------------------------------*/
  1131.     /* Local Variables                                                */
  1132.     /*----------------------------------------------------------------*/
  1133.     gui_button_pen_enum button_event;
  1134.     gui_multi_line_input_box_pen_enum multi_line_input_box_event;
  1135.     gui_EMS_input_box_pen_enum EMS_input_box_event;
  1136.     wgui_status_icon_bar_pen_enum status_icon_bar_event;
  1137.     S16 status_icon_id;
  1139.     /*----------------------------------------------------------------*/
  1140.     /* Code Body                                                      */
  1141.     /*----------------------------------------------------------------*/
  1142.     if (g_pen_to_control == DM_LSK)
  1143.     {
  1144.         gui_icontext_button_translate_pen_event(
  1145.             &MMI_softkeys[MMI_LEFT_SOFTKEY],
  1146.             MMI_PEN_EVENT_UP,
  1147.             point.x,
  1148.             point.y,
  1149.             &button_event);
  1151.         if (button_event == GUI_BUTTON_PEN_UP_INSIDE)
  1152.         {
  1153.             wgui_pen_execute_LSK_handler(KEY_EVENT_UP);
  1154.         }
  1155.     }
  1156.     else if (g_pen_to_control == DM_RSK)
  1157.     {
  1158.         gui_icontext_button_translate_pen_event(
  1159.             &MMI_softkeys[MMI_RIGHT_SOFTKEY],
  1160.             MMI_PEN_EVENT_UP,
  1161.             point.x,
  1162.             point.y,
  1163.             &button_event);
  1165.         if (button_event == GUI_BUTTON_PEN_UP_INSIDE)
  1166.         {
  1167.             wgui_pen_execute_RSK_handler(KEY_EVENT_UP);
  1168.         }
  1169.     }
  1170. #ifdef __MMI_WGUI_CSK_ENABLE__
  1171.     else if (g_pen_to_control == DM_CSK)
  1172.     {
  1173.         gui_icontext_button_translate_pen_event(
  1174.             &MMI_softkeys[MMI_CENTER_SOFTKEY],
  1175.             MMI_PEN_EVENT_UP,
  1176.             point.x,
  1177.             point.y,
  1178.             &button_event);
  1180.         if (button_event == GUI_BUTTON_PEN_UP_INSIDE)
  1181.         {
  1182.             wgui_pen_execute_CSK_handler(KEY_EVENT_UP);
  1183.         }
  1184.     }
  1185. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1186.     else if (g_pen_to_control == DM_STATUS_BAR1)
  1187.     {
  1188.         wgui_status_icon_translate_pen_event(
  1189.             MMI_PEN_EVENT_UP,
  1190.             point.x,
  1191.             point.y,
  1192.             &status_icon_id,
  1193.             &status_icon_bar_event);
  1195.         if (status_icon_bar_event == WGUI_STATUS_ICON_BAR_PEN_SELECT_ICON)      /* select an icon */
  1196.         {
  1197.             wgui_execute_status_icon_pen_event_hdlr(status_icon_id, WGUI_STATUS_ICON_BAR_PEN_SELECT_ICON);
  1198.         }
  1199.     }
  1200.     else if (g_pen_to_control == DM_LIST1)
  1201.     {
  1202.         wgui_general_pen_list_menu_hdlr(point, MMI_PEN_EVENT_UP);
  1203.     }
  1204.     else if (g_pen_to_control == DM_INLINE_FIXED_LIST1)
  1205.     {
  1206.         wgui_general_pen_inline_hdlr(point, MMI_PEN_EVENT_UP);
  1207.     }
  1208.     else if (g_pen_to_control == DM_DYNAMIC_LIST1)
  1209.     {
  1210.         wgui_general_pen_dynamic_list_menu_hdlr(point, MMI_PEN_EVENT_UP);
  1211.     }
  1212.     else if (g_pen_to_control == DM_ASYNCDYNAMIC_LIST1)
  1213.     {
  1214.         wgui_general_pen_asyncdynamic_list_menu_hdlr(point, MMI_PEN_EVENT_UP);
  1215.     }
  1216.     else if (g_pen_to_control == DM_MATRIX_MENU1)
  1217.     {
  1218.         wgui_general_pen_matrix_menu_hdlr(point, MMI_PEN_EVENT_UP);
  1219.     }
  1220.     else if (g_pen_to_control == DM_SLIDE_CONTROL)
  1221.     {
  1222.         wgui_general_pen_slide_control_hdlr(point, MMI_PEN_EVENT_UP);
  1223.     }
  1224.     else if (g_pen_to_control == DM_CALENDAR)
  1225.     {
  1226.         wgui_general_pen_calendar_hdlr(point, MMI_PEN_EVENT_UP);
  1227.     }
  1228.     else if (g_pen_to_control == DM_CIRCULAR_MENU1)
  1229.     {
  1230.         wgui_general_pen_3D_circular_menu_hdlr(point, MMI_PEN_EVENT_UP);
  1231.     }
  1232.     else if (g_pen_to_control == DM_HORIZONTAL_TAB_BAR)
  1233.     {
  1234.         wgui_general_pen_horizontal_tab_bar_hdlr(point, MMI_PEN_EVENT_UP);
  1235.     }
  1236.     else if (g_pen_to_control == DM_MULTILINE_INPUTBOX1)
  1237.     {
  1238.         gui_multi_line_input_box_translate_pen_event(
  1239.             &MMI_multiline_inputbox,
  1240.             MMI_PEN_EVENT_UP,
  1241.             point.x,
  1242.             point.y,
  1243.             &multi_line_input_box_event);
  1244.     }
  1245.     else if (g_pen_to_control == DM_EMS_INPUTBOX1)
  1246.     {
  1247.         gui_EMS_input_box_translate_pen_event(
  1248.             &MMI_EMS_inputbox,
  1249.             MMI_PEN_EVENT_UP,
  1250.             point.x,
  1251.             point.y,
  1252.             &EMS_input_box_event);
  1253.         if (GUI_EMS_INPUT_BOX_PEN_TEXT_UP == EMS_input_box_event)
  1254.         {
  1255.             if (GUI_EMS_INPUT_BOX_PEN_SCROLL_BAR != EMS_input_box_event)
  1256.             {
  1257.                 gui_show_EMS_input_box_ext(&MMI_EMS_inputbox, point.x, point.y);
  1258.                 redraw_EMS_inputbox();
  1259.             }
  1260.         }
  1261.     }
  1262.     else if (g_pen_to_control == DM_TYPICAL_STOPWATCH)
  1263.     {
  1264.         wgui_general_pen_list_menu_hdlr(point, MMI_PEN_EVENT_UP);
  1265.     }
  1266.     else if (g_pen_to_control == DM_DIALER_INPUT_BOX1)
  1267.     {
  1268.         /* CURRENTLY DO NOTHING */
  1269.     }
  1270.     else if (g_pen_to_control == DM_IMAGE)
  1271.     {
  1272.         wgui_execute_dm_image_pen_handler(g_pen_to_control_index, MMI_PEN_EVENT_UP, point);
  1273.     }
  1274.     else if (g_pen_to_control == DM_BUTTON)
  1275.     {
  1276.         gui_icontext_button_translate_pen_event(
  1277.             dm_get_button(g_pen_to_control_index),
  1278.             MMI_PEN_EVENT_UP,
  1279.             point.x,
  1280.             point.y,
  1281.             &button_event);
  1283.         if (button_event == GUI_BUTTON_PEN_UP_INSIDE)
  1284.         {
  1285.             dm_execute_button_handler(g_pen_to_control_index, KEY_EVENT_UP);
  1286.         }
  1287.     }
  1288.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA)
  1289.     {
  1290.         wgui_execute_dm_category_control_area_pen_handler(MMI_PEN_EVENT_UP, point);
  1291.     }
  1292.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA2)
  1293.     {
  1294.         wgui_execute_dm_category_control_area2_pen_handler(MMI_PEN_EVENT_UP, point);
  1295.     }
  1296.     g_pen_to_control = NONE;
  1297. }
  1300. /*****************************************************************************
  1301.  * FUNCTION
  1302.  *  wgui_general_pen_abort_hdlr
  1303.  * DESCRIPTION
  1304.  *  General Pen Abort event handler.
  1305.  * PARAMETERS
  1306.  *  point       [IN]        
  1307.  * RETURNS
  1308.  *  void
  1309.  *****************************************************************************/
  1310. void wgui_general_pen_abort_hdlr(mmi_pen_point_struct point)
  1311. {
  1312.     /*----------------------------------------------------------------*/
  1313.     /* Local Variables                                                */
  1314.     /*----------------------------------------------------------------*/
  1315.     gui_button_pen_enum button_event;
  1316.     gui_multi_line_input_box_pen_enum multi_line_input_box_event;
  1317.     gui_EMS_input_box_pen_enum EMS_input_box_event;
  1318.     wgui_status_icon_bar_pen_enum status_icon_bar_event;
  1319.     S16 status_icon_id;
  1321.     /*----------------------------------------------------------------*/
  1322.     /* Code Body                                                      */
  1323.     /*----------------------------------------------------------------*/
  1324.     if (g_pen_to_control == DM_LSK)
  1325.     {
  1326.         gui_icontext_button_translate_pen_event(
  1327.             &MMI_softkeys[MMI_LEFT_SOFTKEY],
  1328.             MMI_PEN_EVENT_ABORT,
  1329.             point.x,
  1330.             point.y,
  1331.             &button_event);
  1332.     }
  1333.     else if (g_pen_to_control == DM_RSK)
  1334.     {
  1335.         gui_icontext_button_translate_pen_event(
  1336.             &MMI_softkeys[MMI_RIGHT_SOFTKEY],
  1337.             MMI_PEN_EVENT_ABORT,
  1338.             point.x,
  1339.             point.y,
  1340.             &button_event);
  1341.     }
  1342. #ifdef __MMI_WGUI_CSK_ENABLE__
  1343.     else if (g_pen_to_control == DM_CSK)
  1344.     {
  1345.         gui_icontext_button_translate_pen_event(
  1346.             &MMI_softkeys[MMI_CENTER_SOFTKEY],
  1347.             MMI_PEN_EVENT_ABORT,
  1348.             point.x,
  1349.             point.y,
  1350.             &button_event);
  1351.     }
  1352. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1353.     else if (g_pen_to_control == DM_STATUS_BAR1)
  1354.     {
  1355.         wgui_status_icon_translate_pen_event(
  1356.             MMI_PEN_EVENT_ABORT,
  1357.             point.x,
  1358.             point.y,
  1359.             &status_icon_id,
  1360.             &status_icon_bar_event);
  1361.     }
  1362.     else if (g_pen_to_control == DM_LIST1)
  1363.     {
  1364.         wgui_general_pen_list_menu_hdlr(point, MMI_PEN_EVENT_ABORT);
  1365.     }
  1366.     else if (g_pen_to_control == DM_INLINE_FIXED_LIST1)
  1367.     {
  1368.         wgui_general_pen_inline_hdlr(point, MMI_PEN_EVENT_ABORT);
  1369.     }
  1370.     else if (g_pen_to_control == DM_DYNAMIC_LIST1)
  1371.     {
  1372.         wgui_general_pen_dynamic_list_menu_hdlr(point, MMI_PEN_EVENT_ABORT);
  1373.     }
  1374.     else if (g_pen_to_control == DM_ASYNCDYNAMIC_LIST1)
  1375.     {
  1376.         wgui_general_pen_asyncdynamic_list_menu_hdlr(point, MMI_PEN_EVENT_ABORT);
  1377.     }
  1378.     else if (g_pen_to_control == DM_MATRIX_MENU1)
  1379.     {
  1380.         wgui_general_pen_matrix_menu_hdlr(point, MMI_PEN_EVENT_ABORT);
  1381.     }
  1382.     else if (g_pen_to_control == DM_SLIDE_CONTROL)
  1383.     {
  1384.         wgui_general_pen_slide_control_hdlr(point, MMI_PEN_EVENT_ABORT);
  1385.     }
  1386.     else if (g_pen_to_control == DM_CALENDAR)
  1387.     {
  1388.         wgui_general_pen_calendar_hdlr(point, MMI_PEN_EVENT_ABORT);
  1389.     }
  1390.     else if (g_pen_to_control == DM_CIRCULAR_MENU1)
  1391.     {
  1392.         wgui_general_pen_3D_circular_menu_hdlr(point, MMI_PEN_EVENT_ABORT);
  1393.     }
  1394.     else if (g_pen_to_control == DM_HORIZONTAL_TAB_BAR)
  1395.     {
  1396.         wgui_general_pen_horizontal_tab_bar_hdlr(point, MMI_PEN_EVENT_ABORT);
  1397.     }
  1398.     else if (g_pen_to_control == DM_MULTILINE_INPUTBOX1)
  1399.     {
  1400.         gui_multi_line_input_box_translate_pen_event(
  1401.             &MMI_multiline_inputbox,
  1402.             MMI_PEN_EVENT_ABORT,
  1403.             point.x,
  1404.             point.y,
  1405.             &multi_line_input_box_event);
  1406.     }
  1407.     else if (g_pen_to_control == DM_EMS_INPUTBOX1)
  1408.     {
  1409.         gui_EMS_input_box_translate_pen_event(
  1410.             &MMI_EMS_inputbox,
  1411.             MMI_PEN_EVENT_ABORT,
  1412.             point.x,
  1413.             point.y,
  1414.             &EMS_input_box_event);
  1415.     }
  1416.     else if (g_pen_to_control == DM_DIALER_INPUT_BOX1)
  1417.     {
  1418.         /* CURRENTLY DO NOTHING */
  1419.     }
  1420.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA)
  1421.     {
  1422.         wgui_execute_dm_category_control_area_pen_handler(MMI_PEN_EVENT_ABORT, point);
  1423.     }
  1424.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA2)
  1425.     {
  1426.         wgui_execute_dm_category_control_area2_pen_handler(MMI_PEN_EVENT_ABORT, point);
  1427.     }
  1428.     g_pen_to_control = NONE;
  1429. }
  1432. /*****************************************************************************
  1433.  * FUNCTION
  1434.  *  wgui_general_pen_long_tap_hdlr
  1435.  * DESCRIPTION
  1436.  *  General Pen Long Tap event handler.
  1437.  * PARAMETERS
  1438.  *  point       [IN]        
  1439.  * RETURNS
  1440.  *  void
  1441.  *****************************************************************************/
  1442. void wgui_general_pen_long_tap_hdlr(mmi_pen_point_struct point)
  1443. {
  1444.     /*----------------------------------------------------------------*/
  1445.     /* Local Variables                                                */
  1446.     /*----------------------------------------------------------------*/
  1447.     gui_button_pen_enum button_event;
  1448.     gui_multi_line_input_box_pen_enum multi_line_input_box_event;
  1449.     gui_EMS_input_box_pen_enum EMS_input_box_event;
  1450.     wgui_status_icon_bar_pen_enum status_icon_bar_event;
  1451.     S16 status_icon_id;
  1453.     /*----------------------------------------------------------------*/
  1454.     /* Code Body                                                      */
  1455.     /*----------------------------------------------------------------*/
  1456.     if (g_pen_to_control == DM_LSK)
  1457.     {
  1458.         gui_icontext_button_translate_pen_event(
  1459.             &MMI_softkeys[MMI_LEFT_SOFTKEY],
  1460.             MMI_PEN_EVENT_LONG_TAP,
  1461.             point.x,
  1462.             point.y,
  1463.             &button_event);
  1464.         if (button_event == GUI_BUTTON_PEN_LONGTAP)
  1465.         {
  1466.             wgui_pen_execute_LSK_handler(KEY_LONG_PRESS);
  1467.         }
  1468.     }
  1469.     else if (g_pen_to_control == DM_RSK)
  1470.     {
  1471.         gui_icontext_button_translate_pen_event(
  1472.             &MMI_softkeys[MMI_RIGHT_SOFTKEY],
  1473.             MMI_PEN_EVENT_LONG_TAP,
  1474.             point.x,
  1475.             point.y,
  1476.             &button_event);
  1477.         if (button_event == GUI_BUTTON_PEN_LONGTAP)
  1478.         {
  1479.             wgui_pen_execute_RSK_handler(KEY_LONG_PRESS);
  1480.         }
  1481.     }
  1482. #ifdef __MMI_WGUI_CSK_ENABLE__
  1483.     else if (g_pen_to_control == DM_CSK)
  1484.     {
  1485.         gui_icontext_button_translate_pen_event(
  1486.             &MMI_softkeys[MMI_CENTER_SOFTKEY],
  1487.             MMI_PEN_EVENT_LONG_TAP,
  1488.             point.x,
  1489.             point.y,
  1490.             &button_event);
  1491.         if (button_event == GUI_BUTTON_PEN_LONGTAP)
  1492.         {
  1493.             /* Some softkey handlers use GetkeyInfo() */
  1494.             SetkeyInfo(KEY_CSK, KEY_LONG_PRESS);
  1495.             if (GetKeyHandler(KEY_CSK, KEY_LONG_PRESS) != NULL)
  1496.             {
  1497.                 ExecuteCurrKeyHandler(KEY_CSK, KEY_LONG_PRESS);
  1498.             }
  1499.         }
  1500.     }
  1501. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1502.     else if (g_pen_to_control == DM_STATUS_BAR1)
  1503.     {
  1504.         wgui_status_icon_translate_pen_event(
  1505.             MMI_PEN_EVENT_LONG_TAP,
  1506.             point.x,
  1507.             point.y,
  1508.             &status_icon_id,
  1509.             &status_icon_bar_event);
  1510.         if (status_icon_bar_event == WGUI_STATUS_ICON_BAR_PEN_LONG_PRESS_ICON)
  1511.         {
  1512.             wgui_execute_status_icon_pen_event_hdlr(status_icon_id, WGUI_STATUS_ICON_BAR_PEN_LONG_PRESS_ICON);
  1513.         }
  1514.     }
  1515.     else if (g_pen_to_control == DM_LIST1)
  1516.     {
  1517.         wgui_general_pen_list_menu_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1518.     }
  1519.     else if (g_pen_to_control == DM_INLINE_FIXED_LIST1)
  1520.     {
  1521.         wgui_general_pen_inline_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1522.     }
  1523.     else if (g_pen_to_control == DM_DYNAMIC_LIST1)
  1524.     {
  1525.         wgui_general_pen_dynamic_list_menu_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1526.     }
  1527.     else if (g_pen_to_control == DM_ASYNCDYNAMIC_LIST1)
  1528.     {
  1529.         wgui_general_pen_asyncdynamic_list_menu_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1530.     }
  1531.     else if (g_pen_to_control == DM_MATRIX_MENU1)
  1532.     {
  1533.         wgui_general_pen_matrix_menu_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1534.     }
  1535.     else if (g_pen_to_control == DM_SLIDE_CONTROL)
  1536.     {
  1537.         wgui_general_pen_slide_control_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1538.     }
  1539.     else if (g_pen_to_control == DM_CALENDAR)
  1540.     {
  1541.         wgui_general_pen_calendar_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1542.     }
  1543.     else if (g_pen_to_control == DM_CIRCULAR_MENU1)
  1544.     {
  1545.         wgui_general_pen_3D_circular_menu_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1546.     }
  1547.     else if (g_pen_to_control == DM_HORIZONTAL_TAB_BAR)
  1548.     {
  1549.         wgui_general_pen_horizontal_tab_bar_hdlr(point, MMI_PEN_EVENT_LONG_TAP);
  1550.     }
  1551.     else if (g_pen_to_control == DM_MULTILINE_INPUTBOX1)
  1552.     {
  1553.         gui_multi_line_input_box_translate_pen_event(
  1554.             &MMI_multiline_inputbox,
  1555.             MMI_PEN_EVENT_LONG_TAP,
  1556.             point.x,
  1557.             point.y,
  1558.             &multi_line_input_box_event);
  1559.     }
  1560.     else if (g_pen_to_control == DM_EMS_INPUTBOX1)
  1561.     {
  1562.         gui_EMS_input_box_translate_pen_event(
  1563.             &MMI_EMS_inputbox,
  1564.             MMI_PEN_EVENT_LONG_TAP,
  1565.             point.x,
  1566.             point.y,
  1567.             &EMS_input_box_event);
  1568.     }
  1569.     else if (g_pen_to_control == DM_DIALER_INPUT_BOX1)
  1570.     {
  1571.         /* CURRENTLY DO NOTHING */
  1572.     }
  1573.     else if (g_pen_to_control == DM_IMAGE)
  1574.     {
  1575.         wgui_execute_dm_image_pen_handler(g_pen_to_control_index, MMI_PEN_EVENT_LONG_TAP, point);
  1576.     }
  1577.     else if (g_pen_to_control == DM_BUTTON)
  1578.     {
  1579.         gui_icontext_button_translate_pen_event(
  1580.             dm_get_button(g_pen_to_control_index),
  1581.             MMI_PEN_EVENT_LONG_TAP,
  1582.             point.x,
  1583.             point.y,
  1584.             &button_event);
  1585.         if (button_event == GUI_BUTTON_PEN_LONGTAP)
  1586.         {
  1587.             dm_execute_button_handler(g_pen_to_control_index, KEY_EVENT_LONG_PRESS);
  1588.         }
  1590.     }
  1591.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA)
  1592.     {
  1593.         wgui_execute_dm_category_control_area_pen_handler(KEY_EVENT_LONG_PRESS, point);
  1594.     }
  1595.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA2)
  1596.     {
  1597.         wgui_execute_dm_category_control_area2_pen_handler(KEY_EVENT_LONG_PRESS, point);
  1598.     }
  1599. }
  1602. /*****************************************************************************
  1603.  * FUNCTION
  1604.  *  wgui_general_pen_repeat_hdlr
  1605.  * DESCRIPTION
  1606.  *  General Pen Repeat event handler.
  1607.  * PARAMETERS
  1608.  *  point       [IN]        
  1609.  * RETURNS
  1610.  *  void
  1611.  *****************************************************************************/
  1612. void wgui_general_pen_repeat_hdlr(mmi_pen_point_struct point)
  1613. {
  1614.     /*----------------------------------------------------------------*/
  1615.     /* Local Variables                                                */
  1616.     /*----------------------------------------------------------------*/
  1617.     gui_button_pen_enum button_event;
  1618.     gui_multi_line_input_box_pen_enum multi_line_input_box_event;
  1619.     gui_EMS_input_box_pen_enum EMS_input_box_event;
  1620.     wgui_status_icon_bar_pen_enum status_icon_bar_event;
  1621.     S16 status_icon_id;
  1623.     /*----------------------------------------------------------------*/
  1624.     /* Code Body                                                      */
  1625.     /*----------------------------------------------------------------*/
  1626.     if (g_pen_to_control == DM_LSK)
  1627.     {
  1628.         gui_icontext_button_translate_pen_event(
  1629.             &MMI_softkeys[MMI_LEFT_SOFTKEY],
  1630.             MMI_PEN_EVENT_REPEAT,
  1631.             point.x,
  1632.             point.y,
  1633.             &button_event);
  1634.         if (button_event == GUI_BUTTON_PEN_LONGTAP)
  1635.         {
  1636.             /* wgui_pen_execute_LSK_handler(KEY_LONG_PRESS); */
  1637.         }
  1638.     }
  1639.     else if (g_pen_to_control == DM_RSK)
  1640.     {
  1641.         gui_icontext_button_translate_pen_event(
  1642.             &MMI_softkeys[MMI_RIGHT_SOFTKEY],
  1643.             MMI_PEN_EVENT_REPEAT,
  1644.             point.x,
  1645.             point.y,
  1646.             &button_event);
  1647.         if (button_event == GUI_BUTTON_PEN_LONGTAP)
  1648.         {
  1649.             /* wgui_pen_execute_RSK_handler(KEY_LONG_PRESS); */
  1650.         }
  1651.     }
  1652. #ifdef __MMI_WGUI_CSK_ENABLE__
  1653.     else if (g_pen_to_control == DM_CSK)
  1654.     {
  1655.         gui_icontext_button_translate_pen_event(
  1656.             &MMI_softkeys[MMI_CENTER_SOFTKEY],
  1657.             MMI_PEN_EVENT_REPEAT,
  1658.             point.x,
  1659.             point.y,
  1660.             &button_event);
  1661.     }
  1662. #endif /* __MMI_WGUI_CSK_ENABLE__ */ 
  1663.     else if (g_pen_to_control == DM_STATUS_BAR1)
  1664.     {
  1665.         wgui_status_icon_translate_pen_event(
  1666.             MMI_PEN_EVENT_REPEAT,
  1667.             point.x,
  1668.             point.y,
  1669.             &status_icon_id,
  1670.             &status_icon_bar_event);
  1671.         if (status_icon_bar_event == WGUI_STATUS_ICON_BAR_PEN_LONG_PRESS_ICON)  /* long press on an icon */
  1672.         {
  1673.             wgui_execute_status_icon_pen_event_hdlr(status_icon_id, WGUI_STATUS_ICON_BAR_PEN_LONG_PRESS_ICON);
  1674.         }
  1675.     }
  1676.     else if (g_pen_to_control == DM_LIST1)
  1677.     {
  1678.         wgui_general_pen_list_menu_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1679.     }
  1680.     else if (g_pen_to_control == DM_INLINE_FIXED_LIST1)
  1681.     {
  1682.         wgui_general_pen_inline_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1683.     }
  1684.     else if (g_pen_to_control == DM_DYNAMIC_LIST1)
  1685.     {
  1686.         wgui_general_pen_dynamic_list_menu_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1687.     }
  1688.     else if (g_pen_to_control == DM_ASYNCDYNAMIC_LIST1)
  1689.     {
  1690.         wgui_general_pen_asyncdynamic_list_menu_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1691.     }
  1692.     else if (g_pen_to_control == DM_MATRIX_MENU1)
  1693.     {
  1694.         wgui_general_pen_matrix_menu_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1695.     }
  1696.     else if (g_pen_to_control == DM_SLIDE_CONTROL)
  1697.     {
  1698.         wgui_general_pen_slide_control_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1699.     }
  1700.     else if (g_pen_to_control == DM_CALENDAR)
  1701.     {
  1702.         wgui_general_pen_calendar_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1703.     }
  1704.     else if (g_pen_to_control == DM_CIRCULAR_MENU1)
  1705.     {
  1706.         wgui_general_pen_3D_circular_menu_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1707.     }
  1708.     else if (g_pen_to_control == DM_HORIZONTAL_TAB_BAR)
  1709.     {
  1710.         wgui_general_pen_horizontal_tab_bar_hdlr(point, MMI_PEN_EVENT_REPEAT);
  1711.     }
  1712.     else if (g_pen_to_control == DM_MULTILINE_INPUTBOX1)
  1713.     {
  1714.         gui_multi_line_input_box_translate_pen_event(
  1715.             &MMI_multiline_inputbox,
  1716.             MMI_PEN_EVENT_REPEAT,
  1717.             point.x,
  1718.             point.y,
  1719.             &multi_line_input_box_event);
  1720.     }
  1721.     else if (g_pen_to_control == DM_EMS_INPUTBOX1)
  1722.     {
  1723.         gui_EMS_input_box_translate_pen_event(
  1724.             &MMI_EMS_inputbox,
  1725.             MMI_PEN_EVENT_REPEAT,
  1726.             point.x,
  1727.             point.y,
  1728.             &EMS_input_box_event);
  1729.     }
  1730.     else if (g_pen_to_control == DM_DIALER_INPUT_BOX1)
  1731.     {
  1732.         /* CURRENTLY DO NOTHING */
  1733.     }
  1734.     else if (g_pen_to_control == DM_IMAGE)
  1735.     {
  1736.         wgui_execute_dm_image_pen_handler(g_pen_to_control_index, MMI_PEN_EVENT_REPEAT, point);
  1737.     }
  1738.     else if (g_pen_to_control == DM_BUTTON)
  1739.     {
  1740.         gui_icontext_button_translate_pen_event(
  1741.             dm_get_button(g_pen_to_control_index),
  1742.             MMI_PEN_EVENT_REPEAT,
  1743.             point.x,
  1744.             point.y,
  1745.             &button_event);
  1746.         if (button_event == GUI_BUTTON_PEN_REPEAT)
  1747.         {
  1748.             dm_execute_button_handler(g_pen_to_control_index, KEY_EVENT_REPEAT);
  1749.         }
  1750.     }
  1751.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA)
  1752.     {
  1753.         wgui_execute_dm_category_control_area_pen_handler(MMI_PEN_EVENT_REPEAT, point);
  1754.     }
  1755.     else if (g_pen_to_control == DM_CATEGORY_CONTROLLED_AREA2)
  1756.     {
  1757.         wgui_execute_dm_category_control_area2_pen_handler(MMI_PEN_EVENT_REPEAT, point);
  1758.     }
  1759. }
  1762. /*****************************************************************************
  1763.  * FUNCTION
  1764.  *  wgui_general_pen_list_menu_hdlr
  1765.  * DESCRIPTION
  1766.  *  General list menu event handler.
  1767.  * PARAMETERS
  1768.  *  point           [IN]        Pen point
  1769.  *  pen_event       [IN]        Pen event type
  1770.  * RETURNS
  1771.  *  void
  1772.  *****************************************************************************/
  1773. MMI_BOOL wgui_general_pen_list_menu_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  1774. {
  1775.     /*----------------------------------------------------------------*/
  1776.     /* Local Variables                                                */
  1777.     /*----------------------------------------------------------------*/
  1778.     gui_list_pen_enum menu_event;
  1779.     BOOL ret;
  1781.     /*----------------------------------------------------------------*/
  1782.     /* Code Body                                                      */
  1783.     /*----------------------------------------------------------------*/
  1784.     ret = gui_fixed_list_menu_translate_pen_event(&MMI_fixed_list_menu, pen_event, point.x, point.y, &menu_event);
  1786.     if (!ret)
  1787.     {
  1788.         return MMI_FALSE;
  1789.     }
  1791.     if (menu_event == GUI_LIST_PEN_HIGHLIGHT_CHANGED ||
  1792.         menu_event == GUI_LIST_PEN_NEED_REDRAW || menu_event == GUI_LIST_PEN_ITEM_SELECTED)
  1793.     {
  1794.     #ifdef __MMI_INTERACTIVE_PROFILNG__
  1795.         mmi_frm_profiling_delay_start_timer(MMI_FRM_PROFILING_DELAY_LIST_HIGHLIGHT);
  1796.     #endif
  1797.     
  1798.         MMI_fixed_list_menu.pen_redraw_menu_function();
  1799.         
  1800.     #ifdef __MMI_INTERACTIVE_PROFILNG__
  1801.         mmi_frm_profiling_delay_perform(MMI_FRM_PROFILING_DELAY_LIST_HIGHLIGHT);
  1802.     #endif
  1803.     }
  1804.     if (menu_event == GUI_LIST_PEN_ITEM_SELECTED)
  1805.     {
  1806.         if (MMI_fixed_list_menu.pen_event_current_selected_callback_function != NULL)
  1807.         {
  1808.             MMI_fixed_list_menu.pen_event_current_selected_callback_function();
  1809.         }
  1810.         else
  1811.         {
  1812.             wgui_pen_execute_LSK_handler(KEY_EVENT_UP);
  1813.         }
  1814.     }
  1815. #ifdef __MMI_UI_TWO_LINE_MENUITEM_STYLES__
  1816.     if (menu_event == GUI_ICONTEXT_PEN_TWO_LINE_NEXT)
  1817.     {
  1818.         ExecuteCurrKeyHandler(KEY_RIGHT_ARROW,KEY_EVENT_DOWN);
  1819.     }
  1820.     else if (menu_event == GUI_ICONTEXT_PEN_TWO_LINE_PREVIOUS)
  1821.     {
  1822.         ExecuteCurrKeyHandler(KEY_LEFT_ARROW,KEY_EVENT_DOWN);
  1823.     }
  1824. #endif /* __MMI_UI_TWO_LINE_MENUITEM_STYLES__ */
  1825.     return MMI_TRUE;
  1826. }
  1829. /*****************************************************************************
  1830.  * FUNCTION
  1831.  *  wgui_general_pen_inline_hdlr
  1832.  * DESCRIPTION
  1833.  *  General inline list event handler.
  1834.  * PARAMETERS
  1835.  *  point           [IN]        Pen point
  1836.  *  pen_event       [IN]        Pen event type
  1837.  * RETURNS
  1838.  *  void
  1839.  *****************************************************************************/
  1840. MMI_BOOL wgui_general_pen_inline_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  1841. {
  1842.     /*----------------------------------------------------------------*/
  1843.     /* Local Variables                                                */
  1844.     /*----------------------------------------------------------------*/
  1845.     gui_inline_pen_enum inline_event;
  1846.     BOOL ret;
  1848.     /*----------------------------------------------------------------*/
  1849.     /* Code Body                                                      */
  1850.     /*----------------------------------------------------------------*/
  1851.     ret = gui_inline_translate_pen_event(&MMI_fixed_list_menu, pen_event, point.x, point.y, &inline_event);
  1853.     if (!ret)
  1854.     {
  1855.         return MMI_FALSE;
  1856.     }
  1858.     if (inline_event == GUI_INLINE_PEN_NEED_REDRAW)
  1859.     {
  1860.         MMI_fixed_list_menu.pen_redraw_menu_function();
  1861.     }
  1862.     else if (inline_event == GUI_INLINE_PEN_ITEM_SELECTED)
  1863.     {
  1864.         wgui_pen_execute_LSK_handler(KEY_EVENT_UP);
  1865.     }
  1866.     return MMI_TRUE;
  1867. }
  1870. /*****************************************************************************
  1871.  * FUNCTION
  1872.  *  wgui_general_pen_calendar_hdlr
  1873.  * DESCRIPTION
  1874.  *  General calendar event handler.
  1875.  * PARAMETERS
  1876.  *  point           [IN]        Pen point
  1877.  *  pen_event       [IN]        Pen event type
  1878.  * RETURNS
  1879.  *  void
  1880.  *****************************************************************************/
  1881. MMI_BOOL wgui_general_pen_calendar_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  1882. {
  1883.     /*----------------------------------------------------------------*/
  1884.     /* Local Variables                                                */
  1885.     /*----------------------------------------------------------------*/
  1886.     gui_calendar_pen_enum calendar_event;
  1887.     BOOL ret;
  1889.     /*----------------------------------------------------------------*/
  1890.     /* Code Body                                                      */
  1891.     /*----------------------------------------------------------------*/
  1892.     ret = wgui_calendar_translate_pen_event(&MMI_calendar_control, pen_event, point.x, point.y, &calendar_event);
  1894.     if (calendar_event == GUI_CALENDAR_PEN_ITEM_SELECTED)
  1895.     {
  1896.         wgui_pen_execute_LSK_handler(KEY_EVENT_UP);
  1897.     }
  1898.     return ret;
  1899. }
  1902. /*****************************************************************************
  1903.  * FUNCTION
  1904.  *  wgui_general_pen_dynamic_list_menu_hdlr
  1905.  * DESCRIPTION
  1906.  *  General dynamic list menu event handler.
  1907.  * PARAMETERS
  1908.  *  point           [IN]        Pen point
  1909.  *  pen_event       [IN]        Pen event type
  1910.  * RETURNS
  1911.  *  void
  1912.  *****************************************************************************/
  1913. MMI_BOOL wgui_general_pen_dynamic_list_menu_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  1914. {
  1915.     /*----------------------------------------------------------------*/
  1916.     /* Local Variables                                                */
  1917.     /*----------------------------------------------------------------*/
  1918.     gui_list_pen_enum menu_event;
  1919.     BOOL ret;
  1921.     /*----------------------------------------------------------------*/
  1922.     /* Code Body                                                      */
  1923.     /*----------------------------------------------------------------*/
  1924.     ret = gui_dynamic_list_menu_translate_pen_event(&MMI_fixed_list_menu, pen_event, point.x, point.y, &menu_event);
  1926.     if (!ret)
  1927.     {
  1928.         return MMI_FALSE;
  1929.     }
  1931.     if (menu_event == GUI_LIST_PEN_HIGHLIGHT_CHANGED ||
  1932.         menu_event == GUI_LIST_PEN_NEED_REDRAW || menu_event == GUI_LIST_PEN_ITEM_SELECTED)
  1933.     {
  1934.         MMI_fixed_list_menu.pen_redraw_menu_function();
  1935.     }
  1936.     if (menu_event == GUI_LIST_PEN_ITEM_SELECTED)
  1937.     {
  1938.         if (MMI_fixed_list_menu.pen_event_current_selected_callback_function != NULL)
  1939.         {
  1940.             MMI_fixed_list_menu.pen_event_current_selected_callback_function();
  1941.         }
  1942.         else
  1943.         {
  1944.             wgui_pen_execute_LSK_handler(KEY_EVENT_UP);
  1945.         }
  1946.     }
  1947. #ifdef __MMI_UI_TWO_LINE_MENUITEM_STYLES__
  1948.     if (menu_event == GUI_LIST_PEN_TWO_LINE_NEXT)
  1949.     {
  1950.         ExecuteCurrKeyHandler(KEY_RIGHT_ARROW,KEY_EVENT_DOWN);
  1951.     }
  1952.     else if (menu_event == GUI_LIST_PEN_TWO_LINE_PREVIOUS)
  1953.     {
  1954.         ExecuteCurrKeyHandler(KEY_LEFT_ARROW,KEY_EVENT_DOWN);
  1955.     }
  1956. #endif /* __MMI_UI_TWO_LINE_MENUITEM_STYLES__ */
  1957.     return MMI_TRUE;
  1958. }
  1961. /*****************************************************************************
  1962.  * FUNCTION
  1963.  *  wgui_general_pen_asyncdynamic_list_menu_hdlr
  1964.  * DESCRIPTION
  1965.  *  General asyncdynamic list menu event handler.
  1966.  * PARAMETERS
  1967.  *  point           [IN]        Pen point
  1968.  *  pen_event       [IN]        Pen event type
  1969.  * RETURNS
  1970.  *  void
  1971.  *****************************************************************************/
  1972. MMI_BOOL wgui_general_pen_asyncdynamic_list_menu_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  1973. {
  1974.     /*----------------------------------------------------------------*/
  1975.     /* Local Variables                                                */
  1976.     /*----------------------------------------------------------------*/
  1977.     gui_list_pen_enum menu_event;
  1978.     BOOL ret;
  1980.     /*----------------------------------------------------------------*/
  1981.     /* Code Body                                                      */
  1982.     /*----------------------------------------------------------------*/
  1983.     ret = gui_asyncdynamic_list_menu_translate_pen_event(
  1984.             &MMI_fixed_list_menu,
  1985.             pen_event,
  1986.             point.x,
  1987.             point.y,
  1988.             &menu_event);
  1990.     if (!ret)
  1991.     {
  1992.         return MMI_FALSE;
  1993.     }
  1995.     if (menu_event == GUI_LIST_PEN_HIGHLIGHT_CHANGED ||
  1996.         menu_event == GUI_LIST_PEN_NEED_REDRAW || menu_event == GUI_LIST_PEN_ITEM_SELECTED)
  1997.     {
  1998.         MMI_fixed_list_menu.pen_redraw_menu_function();
  1999.     }
  2000.     if (menu_event == GUI_LIST_PEN_ITEM_SELECTED)
  2001.     {
  2002.         if (MMI_fixed_list_menu.pen_event_current_selected_callback_function != NULL)
  2003.         {
  2004.             MMI_fixed_list_menu.pen_event_current_selected_callback_function();
  2005.         }
  2006.         else
  2007.         {
  2008.             wgui_pen_execute_LSK_handler(KEY_EVENT_UP);
  2009.         }
  2010.     }
  2011.     return MMI_TRUE;
  2012. }
  2015. /*****************************************************************************
  2016.  * FUNCTION
  2017.  *  wgui_general_pen_matrix_menu_hdlr
  2018.  * DESCRIPTION
  2019.  *  General matrix menu event handler.
  2020.  * PARAMETERS
  2021.  *  point           [IN]        Pen point
  2022.  *  pen_event       [IN]        Pen event type
  2023.  * RETURNS
  2024.  *  void
  2025.  *****************************************************************************/
  2026. MMI_BOOL wgui_general_pen_matrix_menu_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  2027. {
  2028.     /*----------------------------------------------------------------*/
  2029.     /* Local Variables                                                */
  2030.     /*----------------------------------------------------------------*/
  2031.     gui_matrix_pen_enum menu_event;
  2032.     BOOL ret;
  2034.     /*----------------------------------------------------------------*/
  2035.     /* Code Body                                                      */
  2036.     /*----------------------------------------------------------------*/
  2037.     ret = gui_fixed_matrix_menu_translate_pen_event(&MMI_fixed_matrix_menu, pen_event, point.x, point.y, &menu_event);
  2039.     if (!ret)
  2040.     {
  2041.         return MMI_FALSE;
  2042.     }
  2044.     if (menu_event == GUI_MATRIX_PEN_HIGHLIGHT_CHANGED ||
  2045.         menu_event == GUI_MATRIX_PEN_NEED_REDRAW || menu_event == GUI_MATRIX_PEN_ITEM_SELECTED)
  2046.     {
  2047.     #ifdef __MMI_INTERACTIVE_PROFILNG__
  2048.         mmi_frm_profiling_delay_start_timer(MMI_FRM_PROFILING_DELAY_MATRIX_HIGHLIGHT);
  2049.     #endif
  2050.     
  2051.         gui_lock_double_buffer();
  2052.         show_fixed_matrix();
  2053.         gui_unlock_double_buffer();
  2054.         gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  2055.         
  2056.     #ifdef __MMI_INTERACTIVE_PROFILNG__
  2057.         mmi_frm_profiling_delay_perform(MMI_FRM_PROFILING_DELAY_MATRIX_HIGHLIGHT);
  2058.     #endif
  2059.     }
  2060.     if (menu_event == GUI_MATRIX_PEN_ITEM_SELECTED)
  2061.     {
  2062.         if (MMI_fixed_matrix_menu.pen_event_current_selected_callback_function != NULL)
  2063.         {
  2064.             MMI_fixed_matrix_menu.pen_event_current_selected_callback_function();
  2065.         }
  2066.         else
  2067.         {
  2068.             wgui_pen_execute_LSK_handler(KEY_EVENT_UP);
  2069.         }
  2070.     }
  2071.     return MMI_TRUE;
  2072. }
  2075. /*****************************************************************************
  2076.  * FUNCTION
  2077.  *  wgui_general_pen_slide_control_hdlr
  2078.  * DESCRIPTION
  2079.  *  General slide control event handler.
  2080.  * PARAMETERS
  2081.  *  point           [IN]        Pen point
  2082.  *  pen_event       [IN]        Pen event type
  2083.  * RETURNS
  2084.  *  void
  2085.  *****************************************************************************/
  2086. MMI_BOOL wgui_general_pen_slide_control_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  2087. {
  2088.     /*----------------------------------------------------------------*/
  2089.     /* Local Variables                                                */
  2090.     /*----------------------------------------------------------------*/
  2091.     gui_slide_control_pen_event_enum slide_event;
  2092.     gui_pen_event_param_struct param;
  2093.     BOOL ret;
  2095.     /*----------------------------------------------------------------*/
  2096.     /* Code Body                                                      */
  2097.     /*----------------------------------------------------------------*/
  2098.     ret = wgui_slide_control_translate_pen_event(
  2099.             MMI_current_slide_control,
  2100.             pen_event,
  2101.             point.x,
  2102.             point.y,
  2103.             &slide_event,
  2104.             &param);
  2106.     if (!ret)
  2107.     {
  2108.         return MMI_FALSE;
  2109.     }
  2111.     if (slide_event == GUI_SLIDE_CONTROL_PEN_JUMP_TO_I)
  2112.     {
  2113.         wgui_slide_control_set_value(param._u.i);
  2114.     }
  2115.     return MMI_TRUE;
  2116. }
  2119. /*****************************************************************************
  2120.  * FUNCTION
  2121.  *  wgui_general_pen_3D_circular_menu_hdlr
  2122.  * DESCRIPTION
  2123.  *  General 3D circular menu event handler.
  2124.  * PARAMETERS
  2125.  *  point           [IN]        Pen point
  2126.  *  pen_event       [IN]        Pen event type
  2127.  * RETURNS
  2128.  *  void
  2129.  *****************************************************************************/
  2130. MMI_BOOL wgui_general_pen_3D_circular_menu_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  2131. {
  2132.     /*----------------------------------------------------------------*/
  2133.     /* Local Variables                                                */
  2134.     /*----------------------------------------------------------------*/
  2135.     gui_3D_circular_menu_pen_enum circular_event;
  2136.     BOOL ret;
  2138.     /*----------------------------------------------------------------*/
  2139.     /* Code Body                                                      */
  2140.     /*----------------------------------------------------------------*/
  2141.     ret = gui_3D_circular_menu_translate_pen_event(&wgui_CM3D_menu, pen_event, point.x, point.y, &circular_event);
  2143.     if (!ret)
  2144.     {
  2145.         return MMI_FALSE;
  2146.     }
  2148.     if (circular_event == GUI_3D_CIRCULAR_MENU_PEN_GOTO_NEXT)
  2149.     {
  2150.         circular_3d_menu_next();
  2151.     }
  2152.     else if (circular_event == GUI_3D_CIRCULAR_MENU_PEN_GOTO_PREVIOUS)
  2153.     {
  2154.         circular_3d_menu_previous();
  2155.     }
  2156.     else if (circular_event == GUI_3D_CIRCULAR_MENU_PEN_ITEM_SELECTED)
  2157.     {
  2158.         wgui_pen_execute_LSK_handler(KEY_EVENT_UP);
  2159.     }
  2160.     return MMI_TRUE;
  2161. }
  2164. /*****************************************************************************
  2165.  * FUNCTION
  2166.  *  wgui_general_pen_horizontal_tab_bar_hdlr
  2167.  * DESCRIPTION
  2168.  *  General horizontal rab bar event handler.
  2169.  * PARAMETERS
  2170.  *  point           [IN]        Pen point
  2171.  *  pen_event       [IN]        Pen event type
  2172.  * RETURNS
  2173.  *  void
  2174.  *****************************************************************************/
  2175. MMI_BOOL wgui_general_pen_horizontal_tab_bar_hdlr(mmi_pen_point_struct point, mmi_pen_event_type_enum pen_event)
  2176. {
  2177.     /*----------------------------------------------------------------*/
  2178.     /* Local Variables                                                */
  2179.     /*----------------------------------------------------------------*/
  2181.     /*----------------------------------------------------------------*/
  2182.     /* Code Body                                                      */
  2183.     /*----------------------------------------------------------------*/
  2184.     return wgui_horizontal_tab_bar_translate_pen_event(pen_event, point.x, point.y);
  2185. }
  2188. /*****************************************************************************
  2189.  * FUNCTION
  2190.  *  wgui_register_pen_up_handler
  2191.  * DESCRIPTION
  2192.  *  Register global Pen event handlers.
  2193.  * PARAMETERS
  2194.  *  pen_up_hdlr     [IN]        pen_move_hdlr, pen_abort_hdlr
  2195.  * RETURNS
  2196.  *  void
  2197.  *****************************************************************************/
  2198. void wgui_register_pen_up_handler(mmi_pen_hdlr pen_up_hdlr)
  2199. {
  2200.     /*----------------------------------------------------------------*/
  2201.     /* Local Variables                                                */
  2202.     /*----------------------------------------------------------------*/
  2204.     /*----------------------------------------------------------------*/
  2205.     /* Code Body                                                      */
  2206.     /*----------------------------------------------------------------*/
  2207.     if (pen_up_hdlr != NULL)
  2208.     {
  2209.         mmi_pen_register_up_handler(pen_up_hdlr);
  2210.     }
  2211.     else
  2212.     {
  2213.         MMI_ASSERT(pen_up_hdlr != NULL);
  2214.     }
  2215. }
  2218. /*****************************************************************************
  2219.  * FUNCTION
  2220.  *  wgui_register_pen_down_handler
  2221.  * DESCRIPTION
  2222.  *  Register global Pen event handlers.
  2223.  * PARAMETERS
  2224.  *  pen_down_hdlr       [IN]        pen_up_hdlr, pen_move_hdlr, pen_abort_hdlr
  2225.  * RETURNS
  2226.  *  void
  2227.  *****************************************************************************/
  2228. void wgui_register_pen_down_handler(mmi_pen_hdlr pen_down_hdlr)
  2229. {
  2230.     /*----------------------------------------------------------------*/
  2231.     /* Local Variables                                                */
  2232.     /*----------------------------------------------------------------*/
  2234.     /*----------------------------------------------------------------*/
  2235.     /* Code Body                                                      */
  2236.     /*----------------------------------------------------------------*/
  2237.     if (pen_down_hdlr != NULL)
  2238.     {
  2239.         mmi_pen_register_down_handler(pen_down_hdlr);
  2240.     }
  2241.     else
  2242.     {
  2243.         MMI_ASSERT(pen_down_hdlr != NULL);
  2244.     }
  2245. }
  2248. /*****************************************************************************
  2249.  * FUNCTION
  2250.  *  wgui_register_pen_move_handler
  2251.  * DESCRIPTION
  2252.  *  Register global Pen event handlers.
  2253.  * PARAMETERS
  2254.  *  pen_move_hdlr       [IN]        pen_abort_hdlr
  2255.  * RETURNS
  2256.  *  void
  2257.  *****************************************************************************/
  2258. void wgui_register_pen_move_handler(mmi_pen_hdlr pen_move_hdlr)
  2259. {
  2260.     /*----------------------------------------------------------------*/
  2261.     /* Local Variables                                                */
  2262.     /*----------------------------------------------------------------*/
  2264.     /*----------------------------------------------------------------*/
  2265.     /* Code Body                                                      */
  2266.     /*----------------------------------------------------------------*/
  2267.     if (pen_move_hdlr != NULL)
  2268.     {
  2269.         mmi_pen_register_move_handler(pen_move_hdlr);
  2270.     }
  2271.     else
  2272.     {
  2273.         MMI_ASSERT(pen_move_hdlr != NULL);
  2274.     }
  2275. }
  2278. /*****************************************************************************
  2279.  * FUNCTION
  2280.  *  wgui_register_pen_abort_handler
  2281.  * DESCRIPTION
  2282.  *  Register global Pen event handlers.
  2283.  * PARAMETERS
  2284.  *  pen_abort_hdlr      [IN]        
  2285.  * RETURNS
  2286.  *  void
  2287.  *****************************************************************************/
  2288. void wgui_register_pen_abort_handler(mmi_pen_hdlr pen_abort_hdlr)
  2289. {
  2290.     /*----------------------------------------------------------------*/
  2291.     /* Local Variables                                                */
  2292.     /*----------------------------------------------------------------*/
  2294.     /*----------------------------------------------------------------*/
  2295.     /* Code Body                                                      */
  2296.     /*----------------------------------------------------------------*/
  2297.     if (pen_abort_hdlr != NULL)
  2298.     {
  2299.         mmi_pen_register_abort_handler(pen_abort_hdlr);
  2300.     }
  2301.     else
  2302.     {
  2303.         MMI_ASSERT(pen_abort_hdlr != NULL);
  2304.     }
  2305. }
  2308. /*****************************************************************************
  2309.  * FUNCTION
  2310.  *  wgui_register_pen_repeat_handler
  2311.  * DESCRIPTION
  2312.  *  Register global Pen event handlers.
  2313.  * PARAMETERS
  2314.  *  pen_repeat_hdlr     [IN]        
  2315.  *  pen_down_hdlr, pen_up_hdlr, pen_move_hdlr, pen_abort_hdlr(?)
  2316.  * RETURNS
  2317.  *  void
  2318.  *****************************************************************************/
  2319. void wgui_register_pen_repeat_handler(mmi_pen_hdlr pen_repeat_hdlr)
  2320. {
  2321.     /*----------------------------------------------------------------*/
  2322.     /* Local Variables                                                */
  2323.     /*----------------------------------------------------------------*/
  2325.     /*----------------------------------------------------------------*/
  2326.     /* Code Body                                                      */
  2327.     /*----------------------------------------------------------------*/
  2328.     if (pen_repeat_hdlr != NULL)
  2329.     {
  2330.         mmi_pen_register_repeat_handler(pen_repeat_hdlr);
  2331.     }
  2332.     else
  2333.     {
  2334.         MMI_ASSERT(pen_repeat_hdlr != NULL);
  2335.     }
  2336. }
  2339. /*****************************************************************************
  2340.  * FUNCTION
  2341.  *  wgui_register_pen_long_tap_handler
  2342.  * DESCRIPTION
  2343.  *  Register global Pen event handlers.
  2344.  * PARAMETERS
  2345.  *  pen_long_tap_hdlr       [IN]        
  2346.  *  pen_down_hdlr, pen_up_hdlr, pen_move_hdlr, pen_abort_hdlr(?)
  2347.  * RETURNS
  2348.  *  void
  2349.  *****************************************************************************/
  2350. void wgui_register_pen_long_tap_handler(mmi_pen_hdlr pen_long_tap_hdlr)
  2351. {
  2352.     /*----------------------------------------------------------------*/
  2353.     /* Local Variables                                                */
  2354.     /*----------------------------------------------------------------*/
  2356.     /*----------------------------------------------------------------*/
  2357.     /* Code Body                                                      */
  2358.     /*----------------------------------------------------------------*/
  2359.     if (pen_long_tap_hdlr != NULL)
  2360.     {
  2361.         mmi_pen_register_long_tap_handler(pen_long_tap_hdlr);
  2362.     }
  2363.     else
  2364.     {
  2365.         MMI_ASSERT(pen_long_tap_hdlr != NULL);
  2366.     }
  2367. }
  2370. /*****************************************************************************
  2371.  * FUNCTION
  2372.  *  wgui_register_general_pen_handler
  2373.  * DESCRIPTION
  2374.  *  Register general global Pen event handlers.
  2375.  * PARAMETERS
  2376.  *  void
  2377.  * RETURNS
  2378.  *  void
  2379.  *****************************************************************************/
  2380. void wgui_register_general_pen_handler(void)
  2381. {
  2382.     /*----------------------------------------------------------------*/
  2383.     /* Local Variables                                                */
  2384.     /*----------------------------------------------------------------*/
  2386.     /*----------------------------------------------------------------*/
  2387.     /* Code Body                                                      */
  2388.     /*----------------------------------------------------------------*/
  2389.     mmi_pen_register_up_handler(wgui_general_pen_up_hdlr);
  2390.     mmi_pen_register_down_handler(wgui_general_pen_down_hdlr);
  2391.     mmi_pen_register_move_handler(wgui_general_pen_move_hdlr);
  2392.     mmi_pen_register_abort_handler(wgui_general_pen_abort_hdlr);
  2393.     mmi_pen_register_repeat_handler(wgui_general_pen_repeat_hdlr);
  2394.     mmi_pen_register_long_tap_handler(wgui_general_pen_long_tap_hdlr);
  2395. }
  2398. /*****************************************************************************
  2399.  * FUNCTION
  2400.  *  wgui_empty_pen_handler
  2401.  * DESCRIPTION
  2402.  *  empty Pen event handlers.
  2403.  * PARAMETERS
  2404.  *  point       [IN]        
  2405.  * RETURNS
  2406.  *  void
  2407.  *****************************************************************************/
  2408. void wgui_empty_pen_handler(mmi_pen_point_struct point)
  2409. {
  2410.     /*----------------------------------------------------------------*/
  2411.     /* Local Variables                                                */
  2412.     /*----------------------------------------------------------------*/
  2414.     /*----------------------------------------------------------------*/
  2415.     /* Code Body                                                      */
  2416.     /*----------------------------------------------------------------*/
  2417.     UI_UNUSED_PARAMETER(point);
  2418.     return;
  2419. }
  2422. /*****************************************************************************
  2423.  * FUNCTION
  2424.  *  wgui_clear_pen_handlers
  2425.  * DESCRIPTION
  2426.  *  Clear general global Pen event handlers.
  2427.  * PARAMETERS
  2428.  *  void
  2429.  * RETURNS
  2430.  *  void
  2431.  *****************************************************************************/
  2432. void wgui_clear_pen_handlers(void)
  2433. {
  2434.     /*----------------------------------------------------------------*/
  2435.     /* Local Variables                                                */
  2436.     /*----------------------------------------------------------------*/
  2438.     /*----------------------------------------------------------------*/
  2439.     /* Code Body                                                      */
  2440.     /*----------------------------------------------------------------*/
  2441.     mmi_pen_register_up_handler(wgui_empty_pen_handler);
  2442.     mmi_pen_register_down_handler(wgui_empty_pen_handler);
  2443.     mmi_pen_register_move_handler(wgui_empty_pen_handler);
  2444.     mmi_pen_register_abort_handler(wgui_empty_pen_handler);
  2445.     mmi_pen_register_repeat_handler(wgui_empty_pen_handler);
  2446.     mmi_pen_register_long_tap_handler(wgui_empty_pen_handler);
  2447. }
  2450. /*****************************************************************************
  2451.  * FUNCTION
  2452.  *  wgui_null_pen_hdlr
  2453.  * DESCRIPTION
  2454.  *  dummy pen event handler.
  2455.  * PARAMETERS
  2456.  *  point       [IN]        
  2457.  * RETURNS
  2458.  *  void
  2459.  *****************************************************************************/
  2460. MMI_BOOL wgui_null_pen_hdlr(mmi_pen_point_struct point)
  2461. {
  2462.     /*----------------------------------------------------------------*/
  2463.     /* Local Variables                                                */
  2464.     /*----------------------------------------------------------------*/
  2466.     /*----------------------------------------------------------------*/
  2467.     /* Code Body                                                      */
  2468.     /*----------------------------------------------------------------*/
  2469.     UI_UNUSED_PARAMETER(point);
  2470.     return FALSE;
  2471. }
  2474. /*****************************************************************************
  2475.  * FUNCTION
  2476.  *  wgui_reset_category_screen_control_pen_handler
  2477.  * DESCRIPTION
  2478.  *  Reset pen handler functions for category screen contrl area.
  2479.  * PARAMETERS
  2480.  *  void
  2481.  * RETURNS
  2482.  *  void
  2483.  *****************************************************************************/
  2484. void wgui_reset_category_screen_control_pen_handler(void)
  2485. {
  2486.     /*----------------------------------------------------------------*/
  2487.     /* Local Variables                                                */
  2488.     /*----------------------------------------------------------------*/
  2489.     U8 idx = 0;
  2491.     /*----------------------------------------------------------------*/
  2492.     /* Code Body                                                      */
  2493.     /*----------------------------------------------------------------*/
  2494.     for (idx = 0; idx < MMI_PEN_EVENT_TYPE_MAX; idx++)
  2495.     {
  2496.         wgui_category_control_area_pen_handlers[idx] = wgui_null_pen_hdlr;
  2497.         wgui_category_control_area2_pen_handlers[idx] = wgui_null_pen_hdlr;
  2498.     }
  2499. }
  2502. /*****************************************************************************
  2503.  * FUNCTION
  2504.  *  wgui_register_category_screen_control_area_pen_handlers
  2505.  * DESCRIPTION
  2506.  *  Register pen handler functions for category screen contrl area.
  2507.  * PARAMETERS
  2508.  *  pen_fp          [IN]        Pen handler function
  2509.  *  event_type      [IN]        Pen event type
  2510.  * RETURNS
  2511.  *  void
  2512.  *****************************************************************************/
  2513. void wgui_register_category_screen_control_area_pen_handlers(mmi_pen_handler pen_fp, mmi_pen_event_type_enum event_type)
  2514. {
  2515.     /*----------------------------------------------------------------*/
  2516.     /* Local Variables                                                */
  2517.     /*----------------------------------------------------------------*/
  2519.     /*----------------------------------------------------------------*/
  2520.     /* Code Body                                                      */
  2521.     /*----------------------------------------------------------------*/
  2522.     /* event_type should be one of the events for touch panel */
  2523.     MMI_ASSERT(event_type > -1 && event_type < MMI_PEN_EVENT_TYPE_MAX);
  2524.     wgui_category_control_area_pen_handlers[event_type] = pen_fp;
  2525. }
  2528. /*****************************************************************************
  2529.  * FUNCTION
  2530.  *  wgui_register_category_screen_control_area2_pen_handlers
  2531.  * DESCRIPTION
  2532.  *  Register pen handler functions for category screen contrl area2.
  2533.  * PARAMETERS
  2534.  *  pen_fp          [IN]        Pen handler function
  2535.  *  event_type      [IN]        Pen event type
  2536.  * RETURNS
  2537.  *  void
  2538.  *****************************************************************************/
  2539. void wgui_register_category_screen_control_area2_pen_handlers(
  2540.         mmi_pen_handler pen_fp,
  2541.         mmi_pen_event_type_enum event_type)
  2542. {
  2543.     /*----------------------------------------------------------------*/
  2544.     /* Local Variables                                                */
  2545.     /*----------------------------------------------------------------*/
  2547.     /*----------------------------------------------------------------*/
  2548.     /* Code Body                                                      */
  2549.     /*----------------------------------------------------------------*/
  2550.     /* event_type should be one of the events for touch panel */
  2551.     MMI_ASSERT(event_type > -1 && event_type < MMI_PEN_EVENT_TYPE_MAX);
  2552.     wgui_category_control_area2_pen_handlers[event_type] = pen_fp;
  2553. }
  2556. /*****************************************************************************
  2557.  * FUNCTION
  2558.  *  wgui_reset_image_control_pen_handler
  2559.  * DESCRIPTION
  2560.  *  reset pen event handler function for image controls
  2561.  * PARAMETERS
  2562.  *  void
  2563.  * RETURNS
  2564.  *  void
  2565.  *****************************************************************************/
  2566. void wgui_reset_image_control_pen_handler(void)
  2567. {
  2568.     /*----------------------------------------------------------------*/
  2569.     /* Local Variables                                                */
  2570.     /*----------------------------------------------------------------*/
  2571.     S32 img_idx = 0, event_type = 0;
  2573.     /*----------------------------------------------------------------*/
  2574.     /* Code Body                                                      */
  2575.     /*----------------------------------------------------------------*/
  2576.     for (img_idx = 0; img_idx < DM_MAX_IMAGES; img_idx++)
  2577.         for (event_type = 0; event_type < MMI_PEN_EVENT_TYPE_MAX; event_type++)
  2578.         {
  2579.             wgui_image_pen_handlers[img_idx][event_type] = wgui_null_pen_hdlr;
  2580.         }
  2581. }
  2584. /*****************************************************************************
  2585.  * FUNCTION
  2586.  *  wgui_register_image_control_pen_handlers
  2587.  * DESCRIPTION
  2588.  *  register pen event handler function for image controls
  2589.  * PARAMETERS
  2590.  *  index           [IN]        Image index
  2591.  *  pen_fp          [IN]        Pen handler function
  2592.  *  event_type      [IN]        Pen event type
  2593.  * RETURNS
  2594.  *  void
  2595.  *****************************************************************************/
  2596. void wgui_register_image_control_pen_handlers(S32 index, mmi_pen_handler pen_fp, mmi_pen_event_type_enum event_type)
  2597. {
  2598.     /*----------------------------------------------------------------*/
  2599.     /* Local Variables                                                */
  2600.     /*----------------------------------------------------------------*/
  2602.     /*----------------------------------------------------------------*/
  2603.     /* Code Body                                                      */
  2604.     /*----------------------------------------------------------------*/
  2605.     /* index should not bigger than max number of images supported by draw manager */
  2606.     MMI_ASSERT(index < DM_MAX_IMAGES);
  2608.     /* event_type should be one of the events for touch panel */
  2609.     MMI_ASSERT(event_type > -1 && event_type < MMI_PEN_EVENT_TYPE_MAX);
  2610.     wgui_image_pen_handlers[index][event_type] = pen_fp;
  2611. }
  2614. /*****************************************************************************
  2615.  * FUNCTION
  2616.  *  wgui_test_object_position
  2617.  * DESCRIPTION
  2618.  *  test if the pen inside one object.
  2619.  * PARAMETERS
  2620.  *  pos     [IN]        Pen position
  2621.  *  obj     [IN]        Position info. of one object.
  2622.  * RETURNS
  2623.  *  void
  2624.  *****************************************************************************/
  2625. MMI_BOOL wgui_test_object_position(mmi_pen_point_struct pos, wgui_component_info_struct obj)
  2626. {
  2627.     /*----------------------------------------------------------------*/
  2628.     /* Local Variables                                                */
  2629.     /*----------------------------------------------------------------*/
  2630.     S32 pos_x = pos.x, pos_y = pos.y;
  2631.     S32 obj_x1 = 0, obj_y1 = 0, obj_x2 = 0, obj_y2 = 0;
  2633.     /*----------------------------------------------------------------*/
  2634.     /* Code Body                                                      */
  2635.     /*----------------------------------------------------------------*/
  2636.     obj_x1 = obj.pos_x;
  2637.     obj_x2 = obj.pos_x + obj.width - 1;//052206 NITZ category Calvin
  2638.     obj_y1 = obj.pos_y;
  2639.     obj_y2 = obj.pos_y + obj.height - 1;
  2641.     if (pos_x >= obj_x1 && pos_x <= obj_x2 && pos_y >= obj_y1 && pos_y <= obj_y2)       /* within object */
  2642.     {
  2643.         return MMI_TRUE;
  2644.     }
  2645.     else
  2646.     {
  2647.         return MMI_FALSE;
  2648.     }
  2649. }
  2652. /*****************************************************************************
  2653.  * FUNCTION
  2654.  *  wgui_test_image_object_position
  2655.  * DESCRIPTION
  2656.  *  test if the pen inside one image object.
  2657.  * PARAMETERS
  2658.  *  pos         [IN]        Pen position
  2659.  *  pos_x       [IN]        X-coordnate of the iamge
  2660.  *  pos_y       [IN]        Y-coordnate of the iamge
  2661.  *  img_ptr     [IN]        Iamge
  2662.  * RETURNS
  2663.  *  void
  2664.  *****************************************************************************/
  2665. MMI_BOOL wgui_test_image_object_position(mmi_pen_point_struct pos, S32 pos_x, S32 pos_y, PU8 img_ptr)
  2666. {
  2667.     /*----------------------------------------------------------------*/
  2668.     /* Local Variables                                                */
  2669.     /*----------------------------------------------------------------*/
  2670.     S32 img_width = 0, img_height = 0;
  2671.     wgui_component_info_struct obj;
  2673.     /*----------------------------------------------------------------*/
  2674.     /* Code Body                                                      */
  2675.     /*----------------------------------------------------------------*/
  2676.     gdi_image_get_dimension(img_ptr, &img_width, &img_height);
  2677.     obj.pos_x = pos_x;
  2678.     obj.pos_y = pos_y;
  2679.     obj.width = img_width;
  2680.     obj.height = img_height;
  2682.     return wgui_test_object_position(pos, obj);
  2683. }
  2686. /*****************************************************************************
  2687.  * FUNCTION
  2688.  *  wgui_test_lsk_position
  2689.  * DESCRIPTION
  2690.  *  test if the pen inside LSK.
  2691.  * PARAMETERS
  2692.  *  pos     [IN]        Pen position
  2693.  * RETURNS
  2694.  *  void
  2695.  *****************************************************************************/
  2696. MMI_BOOL wgui_test_lsk_position(mmi_pen_point_struct pos)
  2697. {
  2698.     /*----------------------------------------------------------------*/
  2699.     /* Local Variables                                                */
  2700.     /*----------------------------------------------------------------*/
  2701.     S32 pos_x = pos.x, pos_y = pos.y;
  2702.     S32 obj_x1 = 0, obj_y1 = 0, obj_x2 = 0, obj_y2 = 0;
  2704.     /*----------------------------------------------------------------*/
  2705.     /* Code Body                                                      */
  2706.     /*----------------------------------------------------------------*/
  2707.     obj_x1 = MMI_softkeys[MMI_LEFT_SOFTKEY].x + MMI_softkeys[MMI_LEFT_SOFTKEY].text_x;
  2708.     obj_x2 = obj_x1 + MMI_softkeys[MMI_LEFT_SOFTKEY].text_width;
  2709.     obj_y1 = MMI_softkeys[MMI_LEFT_SOFTKEY].y + MMI_softkeys[MMI_LEFT_SOFTKEY].text_y;
  2710.     obj_y2 = obj_y1 + MMI_softkeys[MMI_LEFT_SOFTKEY].text_height;
  2712.     if (pos_x >= obj_x1 && pos_x <= obj_x2 && pos_y >= obj_y1 && pos_y <= obj_y2)       /* within object */
  2713.     {
  2714.         return MMI_TRUE;
  2715.     }
  2716.     else
  2717.     {
  2718.         return MMI_FALSE;
  2719.     }
  2720. }
  2723. /*****************************************************************************
  2724.  * FUNCTION
  2725.  *  wgui_test_rsk_position
  2726.  * DESCRIPTION
  2727.  *  test if the pen inside RSK.
  2728.  * PARAMETERS
  2729.  *  pos     [IN]        Pen position
  2730.  * RETURNS
  2731.  *  void
  2732.  *****************************************************************************/
  2733. MMI_BOOL wgui_test_rsk_position(mmi_pen_point_struct pos)
  2734. {
  2735.     /*----------------------------------------------------------------*/
  2736.     /* Local Variables                                                */
  2737.     /*----------------------------------------------------------------*/
  2738.     S32 pos_x = pos.x, pos_y = pos.y;
  2739.     S32 obj_x1 = 0, obj_y1 = 0, obj_x2 = 0, obj_y2 = 0;
  2741.     /*----------------------------------------------------------------*/
  2742.     /* Code Body                                                      */
  2743.     /*----------------------------------------------------------------*/
  2744.     obj_x1 = MMI_softkeys[MMI_RIGHT_SOFTKEY].x + MMI_softkeys[MMI_RIGHT_SOFTKEY].text_x;
  2745.     obj_x2 = obj_x1 + MMI_softkeys[MMI_RIGHT_SOFTKEY].text_width;
  2746.     obj_y1 = MMI_softkeys[MMI_RIGHT_SOFTKEY].y + MMI_softkeys[MMI_RIGHT_SOFTKEY].text_y;
  2747.     obj_y2 = obj_y1 + MMI_softkeys[MMI_RIGHT_SOFTKEY].text_height;
  2749.     if (pos_x >= obj_x1 && pos_x <= obj_x2 && pos_y >= obj_y1 && pos_y <= obj_y2)       /* within object */
  2750.     {
  2751.         return MMI_TRUE;
  2752.     }
  2753.     else
  2754.     {
  2755.         return MMI_FALSE;
  2756.     }
  2757. }
  2760. /*****************************************************************************
  2761.  * FUNCTION
  2762.  *  wgui_register_list_item_selected_callback
  2763.  * DESCRIPTION
  2764.  *  register the callback function when a menuitem is selected.(for one specific menuitem)
  2765.  * PARAMETERS
  2766.  *  pen_event_selected_callback_function        [IN]        Callback function
  2767.  * RETURNS
  2768.  *  void
  2769.  *****************************************************************************/
  2770. void wgui_register_list_item_selected_callback(void (*pen_event_selected_callback_function) (void))
  2771. {
  2772.     /*----------------------------------------------------------------*/
  2773.     /* Local Variables                                                */
  2774.     /*----------------------------------------------------------------*/
  2776.     /*----------------------------------------------------------------*/
  2777.     /* Code Body                                                      */
  2778.     /*----------------------------------------------------------------*/
  2779.     MMI_fixed_list_menu.pen_event_current_selected_callback_function = pen_event_selected_callback_function;
  2780.     MMI_fixed_list_menu.pen_event_default_selected_callback_function = NULL;
  2781. }
  2784. /*****************************************************************************
  2785.  * FUNCTION
  2786.  *  wgui_register_list_item_selected_callback_all
  2787.  * DESCRIPTION
  2788.  *  register the callback function when a menuitem is selected.(apply to all menuitem)
  2789.  * PARAMETERS
  2790.  *  pen_event_selected_callback_function        [IN]        Callback function
  2791.  * RETURNS
  2792.  *  void
  2793.  *****************************************************************************/
  2794. void wgui_register_list_item_selected_callback_all(void (*pen_event_selected_callback_function) (void))
  2795. {
  2796.     /*----------------------------------------------------------------*/
  2797.     /* Local Variables                                                */
  2798.     /*----------------------------------------------------------------*/
  2800.     /*----------------------------------------------------------------*/
  2801.     /* Code Body                                                      */
  2802.     /*----------------------------------------------------------------*/
  2803.     MMI_fixed_list_menu.pen_event_current_selected_callback_function = pen_event_selected_callback_function;
  2804.     MMI_fixed_list_menu.pen_event_default_selected_callback_function = pen_event_selected_callback_function;
  2805. }
  2808. /*****************************************************************************
  2809.  * FUNCTION
  2810.  *  wgui_reset_list_item_selected_callback
  2811.  * DESCRIPTION
  2812.  *  reset the callback function when a menuitem is selected.
  2813.  * PARAMETERS
  2814.  *  void
  2815.  * RETURNS
  2816.  *  void
  2817.  *****************************************************************************/
  2818. void wgui_reset_list_item_selected_callback(void)
  2819. {
  2820.     /*----------------------------------------------------------------*/
  2821.     /* Local Variables                                                */
  2822.     /*----------------------------------------------------------------*/
  2824.     /*----------------------------------------------------------------*/
  2825.     /* Code Body                                                      */
  2826.     /*----------------------------------------------------------------*/
  2827.     MMI_fixed_list_menu.pen_event_current_selected_callback_function = NULL;
  2828.     MMI_fixed_list_menu.pen_event_default_selected_callback_function = NULL;
  2829. }
  2832. /*****************************************************************************
  2833.  * FUNCTION
  2834.  *  wgui_reset_matrix_item_selected_callback
  2835.  * DESCRIPTION
  2836.  *  reset the callback function when a menuitem is selected.
  2837.  * PARAMETERS
  2838.  *  void
  2839.  * RETURNS
  2840.  *  void
  2841.  *****************************************************************************/
  2842. void wgui_reset_matrix_item_selected_callback(void)
  2843. {
  2844.     /*----------------------------------------------------------------*/
  2845.     /* Local Variables                                                */
  2846.     /*----------------------------------------------------------------*/
  2848.     /*----------------------------------------------------------------*/
  2849.     /* Code Body                                                      */
  2850.     /*----------------------------------------------------------------*/
  2851.     MMI_fixed_matrix_menu.pen_event_current_selected_callback_function = NULL;
  2852.     MMI_fixed_matrix_menu.pen_event_default_selected_callback_function = NULL;
  2853. }
  2856. /*****************************************************************************
  2857.  * FUNCTION
  2858.  *  wgui_register_matrix_item_selected_callback
  2859.  * DESCRIPTION
  2860.  *  register the callback function when a menuitem is selected.(for one specific menuitem)
  2861.  * PARAMETERS
  2862.  *  pen_event_selected_callback_function        [IN]        Callback function
  2863.  * RETURNS
  2864.  *  void
  2865.  *****************************************************************************/
  2866. void wgui_register_matrix_item_selected_callback(void (*pen_event_selected_callback_function) (void))
  2867. {
  2868.     /*----------------------------------------------------------------*/
  2869.     /* Local Variables                                                */
  2870.     /*----------------------------------------------------------------*/
  2872.     /*----------------------------------------------------------------*/
  2873.     /* Code Body                                                      */
  2874.     /*----------------------------------------------------------------*/
  2875.     MMI_fixed_matrix_menu.pen_event_current_selected_callback_function = pen_event_selected_callback_function;
  2876.     MMI_fixed_matrix_menu.pen_event_default_selected_callback_function = NULL;
  2877. }
  2880. /*****************************************************************************
  2881.  * FUNCTION
  2882.  *  wgui_register_matrix_item_selected_callback_all
  2883.  * DESCRIPTION
  2884.  *  register the callback function when a menuitem is selected.(apply to all menuitem)
  2885.  * PARAMETERS
  2886.  *  pen_event_selected_callback_function        [IN]        Callback function
  2887.  * RETURNS
  2888.  *  void
  2889.  *****************************************************************************/
  2890. void wgui_register_matrix_item_selected_callback_all(void (*pen_event_selected_callback_function) (void))
  2891. {
  2892.     /*----------------------------------------------------------------*/
  2893.     /* Local Variables                                                */
  2894.     /*----------------------------------------------------------------*/
  2896.     /*----------------------------------------------------------------*/
  2897.     /* Code Body                                                      */
  2898.     /*----------------------------------------------------------------*/
  2899.     MMI_fixed_matrix_menu.pen_event_current_selected_callback_function = pen_event_selected_callback_function;
  2900.     MMI_fixed_matrix_menu.pen_event_default_selected_callback_function = pen_event_selected_callback_function;
  2901. }
  2903. #ifdef __J2ME__
  2906. /*****************************************************************************
  2907.  * FUNCTION
  2908.  *  j2me_get_category_index_by_position
  2909.  * DESCRIPTION
  2910.  *  
  2911.  * PARAMETERS
  2912.  *  pen_event       [IN]        
  2913.  *  point           [IN]        
  2914.  *  is_selected     [?]         
  2915.  * RETURNS
  2916.  *  
  2917.  *****************************************************************************/
  2918. int j2me_get_category_index_by_position(int pen_event, mmi_pen_point_struct point, kal_bool *is_selected)
  2919. {
  2920.     /*----------------------------------------------------------------*/
  2921.     /* Local Variables                                                */
  2922.     /*----------------------------------------------------------------*/
  2923.     gui_list_pen_enum menu_event;
  2924.     BOOL ret;
  2926.     /*----------------------------------------------------------------*/
  2927.     /* Code Body                                                      */
  2928.     /*----------------------------------------------------------------*/
  2929.     ret = gui_fixed_list_menu_translate_pen_event(&MMI_fixed_list_menu, pen_event, point.x, point.y, &menu_event);
  2931.     if (!ret)   /* Not in list menu */
  2932.     {
  2933.         return MMI_FALSE;
  2934.     }
  2936.     if (menu_event == GUI_LIST_PEN_HIGHLIGHT_CHANGED ||
  2937.         menu_event == GUI_LIST_PEN_NEED_REDRAW || menu_event == GUI_LIST_PEN_ITEM_SELECTED)
  2938.     {
  2939.         gui_lock_double_buffer();
  2940.         redraw_fixed_list();
  2941.         gui_unlock_double_buffer();
  2942.         /* gui_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height -1); */
  2943.         jui_widget_refresh_lcd(0, 0, UI_device_width - 1, UI_device_height - 1);
  2944.     }
  2945.     if (menu_event == GUI_LIST_PEN_ITEM_SELECTED)
  2946.     {
  2947.         *is_selected = KAL_TRUE;
  2948.     }
  2949.     else
  2950.     {
  2951.         *is_selected = KAL_FALSE;
  2952.     }
  2953.     return MMI_fixed_list_menu.highlighted_item;
  2954. }
  2956. #endif /* __J2ME__ */ 
  2958. #endif /* defined(__MMI_TOUCH_SCREEN__) */