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

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

MTK

开发平台：

C/C++

PhoneSetup.c：源码内容
  1.        U32 menuItemId=-1; */
  3.     /* 1 Call Exit Handler */
  4.     EntryNewScreen(SCR9003_INITIALSETUP, ExitPhnsetScr, EntryPhnsetScr, NULL);
  6.     /* 2 Get current screen to gui buffer  for history purposes */
  7.     guiBuffer = GetCurrGuiBuffer(SCR9003_INITIALSETUP);
  9.     /* 3. Retrieve no of child of menu item to be displayed */
  10.     /* diamond, 2005/07/01 add _Ext to menu item functions */
  11.     nNumofItem = GetNumOfChild_Ext(MENU9102_INITIAL_SETUP);
  13.     /* 4. Get attribute of menu to be displayed */
  14.     nDispAttribute = GetDispAttributeOfItem(MENU9102_INITIAL_SETUP);
  16.     /* 5. Retrieve string ids in sequence of given menu item to be displayed */
  17.     /* diamond, 2005/07/01 add _Ext to menu item functions */
  18.     GetSequenceStringIds_Ext(MENU9102_INITIAL_SETUP, nStrItemList);
  20.     /* 6 Set current parent id */
  21.     SetParentHandler(MENU9102_INITIAL_SETUP);
  23.     /* 7 Register highlight handler to be called in menu screen */
  24.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  26.     /* 8 Construct the Hints List */
  27.     ConstructHintsList(MENU9102_INITIAL_SETUP, ItemType);
  29. #ifdef __MMI_PHNSET_TWO_LINE_MENUITEM_DISPLAY__
  30.     if (!guiBuffer)
  31.     {
  32.         mmi_phnset_2line_read_setting();
  33.     }
  34.     is_inline_menu_exist = 1;
  35.     wgui_set_pfn_to_get_display_style(mmi_phnset_2line_get_display_style);
  36.     wgui_set_pfn_to_get_current_menu_item_properties(mmi_phnset_2line_get_menuitem_properties);
  37. #endif /* __MMI_PHNSET_TWO_LINE_MENUITEM_DISPLAY__ */ 
  39.     ShowCategory52Screen(
  40.         STR_MENU9102_INITIAL_SETUP,
  41.         MAIN_MENU_TITLE_SETTINGS_ICON,
  42.         STR_GLOBAL_OK,
  43.         IMG_GLOBAL_OK,
  44.         STR_GLOBAL_BACK,
  45.         IMG_GLOBAL_BACK,
  46.         nNumofItem,
  47.         nStrItemList,
  48.         (PU16) gIndexIconsImageList,
  49.         ItemType,
  50.         0,
  51.         0,
  52.         guiBuffer);
  54.     /* 9.Register function with right softkey */
  55.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  57. #ifndef __MMI_PHNSET_TWO_LINE_MENUITEM_DISPLAY__
  58.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  59. #endif 
  61. }
  64. /*****************************************************************************
  65.  * FUNCTION
  66.  *  ExitPhnsetScr
  67.  * DESCRIPTION
  68.  *  This function is Exit function for Phonesetup
  69.  *  Following functions:
  70.  * PARAMETERS
  71.  *  void
  72.  *  a(?)        [IN/OUT]        
  73.  *  b(?)        [IN]            
  74.  * RETURNS
  75.  *  void
  76.  *****************************************************************************/
  77. void ExitPhnsetScr(void)
  78. {
  79.     /*----------------------------------------------------------------*/
  80.     /* Local Variables                                                */
  81.     /*----------------------------------------------------------------*/
  83. #if (  defined(__MMI_NITZ__) && !defined(__MMI_AUTOTIMEZONE_IN_DATEANDTIME__))
  84.     S16 error;
  86.     /*----------------------------------------------------------------*/
  87.     /* Code Body                                                      */
  88.     /*----------------------------------------------------------------*/
  89.     /* Only Write To NVRAM if the value is changes for ON/OFF Keys */
  90.     if (g_phnset_cntx_p->NITZDirtyFlag == TRUE)
  91.     {
  92.         WriteValue(NVRAM_SETTING_AUTOUPDATE_DT_TIME, &(g_phnset_cntx_p->curNITZStatus), DS_BYTE, &error);
  93.         g_phnset_cntx_p->NITZDirtyFlag = FALSE;
  94.     }
  95. #endif /* (  defined(__MMI_NITZ__) && !defined(__MMI_AUTOTIMEZONE_IN_DATEANDTIME__)) */ 
  97. #ifdef __MMI_PHNSET_TWO_LINE_MENUITEM_DISPLAY__
  98.     is_inline_menu_exist = 0;
  99. #endif 
  100. }
  103. /*****************************************************************************
  104.  * FUNCTION
  105.  *  HighlightPhnsetScr
  106.  * DESCRIPTION
  107.  *  This function is highlight handler for Phonesetup
  108.  *  Follow functions: EntryPhnsetScr
  109.  * PARAMETERS
  110.  *  void
  111.  *  a(?)        [IN/OUT]        
  112.  *  b(?)        [IN]            
  113.  * RETURNS
  114.  *  void
  115.  *****************************************************************************/
  116. void HighlightPhnsetScr(void)
  117. {
  118.     /*----------------------------------------------------------------*/
  119.     /* Local Variables                                                */
  120.     /*----------------------------------------------------------------*/
  122.     /*----------------------------------------------------------------*/
  123.     /* Code Body                                                      */
  124.     /*----------------------------------------------------------------*/
  125.     /* 1 Change left soft key icon and label */
  126.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  127.     /* 2 Change right soft key icon and label */
  128.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  130.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  131.     /* 3 Register function for left soft key */
  132.     SetLeftSoftkeyFunction(EntryPhnsetScr, KEY_EVENT_UP);
  133.     SetKeyHandler(EntryPhnsetScr, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  134.     /* 4 Register function for right soft key */
  135.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  136. }
  138. /* Robin 0603: G12C request -- Add Display Setup menu */
  139. #ifdef __MMI_DISP_SETUP_LEVEL_UP__
  142. /*****************************************************************************
  143.  * FUNCTION
  144.  *  HighlightDispSetup
  145.  * DESCRIPTION
  146.  *  This function is highlight handler for Display Setup menu item (same level with pPhone Setup)
  147.  *  Follow functions:
  148.  * PARAMETERS
  149.  *  void
  150.  *  a(?)        [IN/OUT]        
  151.  *  b(?)        [IN]            
  152.  * RETURNS
  153.  *  void
  154.  *****************************************************************************/
  155. void HighlightDispSetup(void)
  156. {
  157.     /*----------------------------------------------------------------*/
  158.     /* Local Variables                                                */
  159.     /*----------------------------------------------------------------*/
  161.     /*----------------------------------------------------------------*/
  162.     /* Code Body                                                      */
  163.     /*----------------------------------------------------------------*/
  164.     /* Change right soft key icon and label */
  165.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  166.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  168.     /* Register function for left soft key */
  169.     SetLeftSoftkeyFunction(EntryDispSetup, KEY_EVENT_UP);
  170.     SetKeyHandler(EntryDispSetup, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  172.     /* Register function for right soft key */
  173.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  174.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  175. }
  178. /*****************************************************************************
  179.  * FUNCTION
  180.  *  EntryDispSetup
  181.  * DESCRIPTION
  182.  *  This function is Entry function for Display Setup
  183.  * PARAMETERS
  184.  *  void
  185.  *  a(?)        [IN/OUT]        
  186.  *  b(?)        [IN]            
  187.  * RETURNS
  188.  *  void
  189.  *****************************************************************************/
  190. void EntryDispSetup(void)
  191. {
  192.     /*----------------------------------------------------------------*/
  193.     /* Local Variables                                                */
  194.     /*----------------------------------------------------------------*/
  195.     U16 nStrItemList[MAX_SUB_MENUS];    /* Stores the strings id of submenus returned */
  196.     U16 nNumofItem;                     /* Stores no of children in the submenu */
  197.     U16 nDispAttribute;                 /* Stores display attribue */
  198.     U8 *guiBuffer;                      /* Buffer holding history data */
  199.     U8 *ItemType[MAX_SUB_MENUS];
  200.     U32 maskingByte = -1;
  201.     U32 menuItemId = -1;
  203.     /*----------------------------------------------------------------*/
  204.     /* Code Body                                                      */
  205.     /*----------------------------------------------------------------*/
  206.     /* 1 Call Exit Handler */
  207.     EntryNewScreen(SCR_DISP_SETUP, NULL, EntryDispSetup, NULL);
  209.     /* 2 Get current screen to gui buffer  for history purposes */
  210.     guiBuffer = GetCurrGuiBuffer(SCR_DISP_SETUP);
  212.     /* 3. Retrieve no of child of menu item to be displayed */
  213.     nNumofItem = GetNumOfChild(MENU_DISP_SETUP);
  215.     /* 4. Get attribute of menu to be displayed */
  216.     nDispAttribute = GetDispAttributeOfItem(MENU_DISP_SETUP);
  218.     /* 5. Retrieve string ids in sequence of given menu item to be displayed */
  219.     GetSequenceStringIds(MENU_DISP_SETUP, nStrItemList);
  221.     /* 6 Set current parent id */
  222.     SetParentHandler(MENU_DISP_SETUP);
  224.     /* 7 Register highlight handler to be called in menu screen */
  225.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  227.     /* 8 Construct the Hints List */
  228.     ConstructHintsList(MENU_DISP_SETUP, ItemType);
  230.     ShowCategory52Screen(
  231.         STR_DISP_SETUP,
  232.         MAIN_MENU_TITLE_SETTINGS_ICON,
  233.         STR_GLOBAL_OK,
  234.         IMG_GLOBAL_OK,
  235.         STR_GLOBAL_BACK,
  236.         IMG_GLOBAL_BACK,
  237.         nNumofItem,
  238.         nStrItemList,
  239.         (PU16) gIndexIconsImageList,
  240.         ItemType,
  241.         0,
  242.         0,
  243.         guiBuffer);
  245.     /* 9.Register function with right softkey */
  246.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  247.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  249.     /* 10. Register Exit handler */
  250.     //SetExitHandler(SCR9003_INITIALSETUP, ExitPhnsetScr);
  251.     //SetGenericExitHandler( SCR_DISP_SETUP, NULL, EntryDispSetup);
  252. }
  254. #endif /* __MMI_DISP_SETUP_LEVEL_UP__ */ 
  257. /*****************************************************************************
  258.  * FUNCTION
  259.  *  HighlightPhnsetIdleScrDisp
  260.  * DESCRIPTION
  261.  *  This function is highlight handler for Phonesetup-> IdleScreenDisplay
  262.  *  Follow functions:
  263.  * PARAMETERS
  264.  *  void
  265.  *  a(?)        [IN/OUT]        
  266.  *  b(?)        [IN]            
  267.  * RETURNS
  268.  *  void
  269.  *****************************************************************************/
  270. void HighlightPhnsetIdleScrDisp(void)
  271. {
  272.     /*----------------------------------------------------------------*/
  273.     /* Local Variables                                                */
  274.     /*----------------------------------------------------------------*/
  276.     /*----------------------------------------------------------------*/
  277.     /* Code Body                                                      */
  278.     /*----------------------------------------------------------------*/
  279.     /* Change right soft key icon and label */
  280.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  281.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  283.     /* Register function for left soft key */
  284.     SetLeftSoftkeyFunction(EntryPhnsetIdleScrDisp, KEY_EVENT_UP);
  285.     SetKeyHandler(EntryPhnsetIdleScrDisp, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  287.     /* Register function for right soft key */
  288.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  289.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  290. }
  293. /*****************************************************************************
  294.  * FUNCTION
  295.  *  EntryPhnsetIdleScrDisp
  296.  * DESCRIPTION
  297.  *  This function is Exit function for Phonesetup->IdleScreenDisplay
  298.  *  Following functions:
  299.  * PARAMETERS
  300.  *  void
  301.  *  a(?)        [IN/OUT]        
  302.  *  b(?)        [IN]            
  303.  * RETURNS
  304.  *  void
  305.  *****************************************************************************/
  306. void EntryPhnsetIdleScrDisp(void)
  307. {
  308.     /*----------------------------------------------------------------*/
  309.     /* Local Variables                                                */
  310.     /*----------------------------------------------------------------*/
  311.     U16 nStrItemList[MAX_SUB_MENUS];    /* Stores the strings id of submenus returned */
  312.     U16 nNumofItem;                     /* Stores no of children in the submenu */
  313.     U16 nDispAttribute;                 /* Stores display attribue */
  314.     U8 *guiBuffer;                      /* Buffer holding history data */
  315.     U8 *IdleScrDispType[MAX_SUB_MENUS];
  317.     /*----------------------------------------------------------------*/
  318.     /* Code Body                                                      */
  319.     /*----------------------------------------------------------------*/
  320.     /* Call Exit Handler */
  321.     EntryNewScreen(SCR_IDLE_SCR_DISP, ExitPhnsetIdleScrDisp, EntryPhnsetIdleScrDisp, NULL);
  323.     /* Get current screen to gui buffer  for history purposes */
  324.     guiBuffer = GetCurrGuiBuffer(SCR_IDLE_SCR_DISP);
  326.     /* Retrieve no of child of menu item to be displayed */
  327.     nNumofItem = GetNumOfChild_Ext(MENU_IDLE_SCR_DISP);
  329.     /* Get attribute of menu to be displayed */
  330.     nDispAttribute = GetDispAttributeOfItem(MENU_IDLE_SCR_DISP);
  332.     /* Retrieve string ids in sequence of given menu item to be displayed */
  333.     GetSequenceStringIds_Ext(MENU_IDLE_SCR_DISP, nStrItemList);
  335.     /* Set current parent id */
  336.     SetParentHandler(MENU_IDLE_SCR_DISP);
  338.     /* Register highlight handler to be called in menu screen */
  339.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  341.     /* If Screen Saver is Off then Set The HintHnadler to NULL instead of
  342.        passing empty screen */
  343.     if (PhnsetGetCurScrSvrStatus() != SET_SS_STATUS_OFF)
  344.     {
  345.         SetHintHandler(MENU_SETTING_SCR_SVR, HintPhnsetScreenSaver);
  346.     }
  347.     else
  348.     {
  349.         SetHintHandler(MENU_SETTING_SCR_SVR, NULL);
  350.     }
  352.     /* Constrct Hint for Idle Screen Display */
  353.     ConstructHintsList(MENU_IDLE_SCR_DISP, IdleScrDispType);
  355.     /* Display Category Screen */
  356.     ShowCategory52Screen(
  357.         STR_IDLE_SCR_DISP,
  358.         MAIN_MENU_TITLE_SETTINGS_ICON,
  359.         STR_GLOBAL_OK,
  360.         IMG_GLOBAL_OK,
  361.         STR_GLOBAL_BACK,
  362.         IMG_GLOBAL_BACK,
  363.         nNumofItem,
  364.         nStrItemList,
  365.         (PU16) gIndexIconsImageList,
  366.         IdleScrDispType,
  367.         0,
  368.         0,
  369.         guiBuffer);
  371.     /* Register function with softkey */
  372.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  373.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  375. }
  378. /*****************************************************************************
  379.  * FUNCTION
  380.  *  ExitPhnsetIdleScrDisp
  381.  * DESCRIPTION
  382.  *  This function is Exit function for Phonesetup->IdleScreenDisplay
  383.  *  Functionality: Save 1. Save Owner number  2. Show date and time status
  384.  * PARAMETERS
  385.  *  void
  386.  *  a(?)        [IN/OUT]        
  387.  *  b(?)        [IN]            
  388.  * RETURNS
  389.  *  void
  390.  *****************************************************************************/
  391. void ExitPhnsetIdleScrDisp(void)
  392. {
  393.     /*----------------------------------------------------------------*/
  394.     /* Local Variables                                                */
  395.     /*----------------------------------------------------------------*/
  396.     S16 error;
  398.     /*----------------------------------------------------------------*/
  399.     /* Code Body                                                      */
  400.     /*----------------------------------------------------------------*/
  401.     /* Save NVRAM only when value is changed for date time and 
  402.        own type on idle screen */
  403.     if (g_phnset_cntx_p->ShowDtDirtyFlag == TRUE)
  404.     {
  405.         WriteValue(NVRAM_SETTING_STATUS_DT_TIME, &(g_phnset_cntx_p->curShowDtStatus), DS_BYTE, &error);
  406.         g_phnset_cntx_p->ShowDtDirtyFlag = FALSE;
  407.     }
  408.     if (g_phnset_cntx_p->ShowOwnNumDirtyFlag == TRUE)
  409.     {
  410.         WriteValue(NVRAM_SETTING_OWNER_NO, &(g_phnset_cntx_p->curShowOwnNumStatus), DS_BYTE, &error);
  411.         g_phnset_cntx_p->ShowOwnNumDirtyFlag = FALSE;
  412.     }
  413.     /* Lisen 0921-1 */
  414. #if defined(__MMI_OPERATOR_NAME_MENU__)
  415.     if (g_phnset_cntx_p->ShowOPNDirtyFlag == TRUE)
  416.     {
  417.         WriteValue(NVRAM_SETTING_OPN_DISPLAY, &(g_phnset_cntx_p->curShowOPNStatus), DS_BYTE, &error);
  418.         g_phnset_cntx_p->ShowOPNDirtyFlag = FALSE;
  419.     }
  420. #endif /* defined(__MMI_OPERATOR_NAME_MENU__) */ 
  421. }
  423. #ifdef __MMI_MAINMENU_STYLE_CHANGE_EN__
  426. /*****************************************************************************
  427.  * FUNCTION
  428.  *  HintPhnsetMainMenuStyle
  429.  * DESCRIPTION
  430.  *  This function is Hint handler for Phonesetup->IdleScreenDisplay --> Mainmenu style
  431.  *  Follow functions:
  432.  * PARAMETERS
  433.  *  index       [IN]            
  434.  *  a(?)        [IN/OUT]        
  435.  *  b(?)        [IN]            
  436.  * RETURNS
  437.  *  void
  438.  *****************************************************************************/
  439. void HintPhnsetMainMenuStyle(U16 index)
  440. {
  441.     /*----------------------------------------------------------------*/
  442.     /* Local Variables                                                */
  443.     /*----------------------------------------------------------------*/
  444.     PS8 p = NULL;
  445.     U8 style = PhnsetGetMainMenuStyle();
  447.     /*----------------------------------------------------------------*/
  448.     /* Code Body                                                      */
  449.     /*----------------------------------------------------------------*/
  450.     switch (style)
  451.     {
  452.     #ifdef __MMI_MAINMENU_MATRIX_SUPPORT__  /* 071705 Calvin added */
  453.         case PHNSET_MAINMENU_STYLE_MATRIX:
  454.             p = GetString(STR_MAINMENU_STYLE_MATRIX);
  455.             break;
  456.     #endif /* __MMI_MAINMENU_MATRIX_SUPPORT__ */ 
  458.     #ifdef __MMI_MAINMENU_PAGE_SUPPORT__    /* 071705 Calvin added */
  459.         case PHNSET_MAINMENU_STYLE_PAGE:
  460.             p = GetString(STR_MAINMENU_STYLE_PAGE);
  461.             break;
  462.     #endif /* __MMI_MAINMENU_PAGE_SUPPORT__ */ 
  464.     #ifdef __MMI_MAINMENU_LIST_SUPPORT__    /* 071705 Calvin added */
  465.         case PHNSET_MAINMENU_STYLE_LIST:
  466.             p = GetString(STR_MAINMENU_STYLE_LIST);
  467.             break;
  468.     #endif /* __MMI_MAINMENU_LIST_SUPPORT__ */ 
  470.     #ifdef __MMI_MAINMENU_CIRCULAR_SUPPORT__        /* 071705 Calvin modified */
  471.         case PHNSET_MAINMENU_STYLE_CIRCULE:
  472.             p = GetString(STR_MAINMENU_STYLE_CIRCULAR);
  473.             break;
  474.     #endif /* __MMI_MAINMENU_CIRCULAR_SUPPORT__ */ 
  476.     #ifdef __MMI_MAINMENU_ROTATE_SUPPORT__
  477.         case PHNSET_MAINMENU_STYLE_ROTATE:
  478.             p = GetString(STR_MAINMENU_STYLE_ROTATE);   /* PDG1   Manish */
  479.             break;
  480.     #endif /* __MMI_MAINMENU_ROTATE_SUPPORT__ */ 
  482.     #ifdef __MMI_MAINMENU_TAB_SUPPORT__     /* 071705 Calvin modified */
  483.         case PHNSET_MAINMENU_STYLE_TAB:
  484.             p = GetString(STR_MAINMENU_STYLE_TAB);
  485.             break;
  486.     #endif /* __MMI_MAINMENU_TAB_SUPPORT__ */ 
  488.         default:
  489.             p = GetString(STR_GLOBAL_EMPTY);
  490.             break;
  491.     }
  492.     pfnUnicodeStrcpy((PS8) hintData[index], (PS8) p);
  494. }
  497. /*****************************************************************************
  498.  * FUNCTION
  499.  *  HighlightPhnsetMainMenuStyle
  500.  * DESCRIPTION
  501.  *  This function is Highlight handler for Phonesetup->IdleScreenDisplay --> Mainmenu style
  502.  *  Follow functions: EntryPhnsetMainMenuStyle
  503.  * PARAMETERS
  504.  *  void
  505.  *  a(?)        [IN/OUT]        
  506.  *  b(?)        [IN]            
  507.  * RETURNS
  508.  *  void
  509.  *****************************************************************************/
  510. void HighlightPhnsetMainMenuStyle(void)
  511. {
  512.     /*----------------------------------------------------------------*/
  513.     /* Local Variables                                                */
  514.     /*----------------------------------------------------------------*/
  516.     /*----------------------------------------------------------------*/
  517.     /* Code Body                                                      */
  518.     /*----------------------------------------------------------------*/
  519.     /* Change right soft key icon and label */
  520.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  521.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  523.     /* Register function for left soft key */
  524.     SetLeftSoftkeyFunction(EntryPhnsetMainMenuStyle, KEY_EVENT_UP);
  525.     SetKeyHandler(EntryPhnsetMainMenuStyle, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  527.     /* Register function for right soft key */
  528.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  529.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  530. }
  533. /*****************************************************************************
  534.  * FUNCTION
  535.  *  EntryPhnsetMainMenuStyle
  536.  * DESCRIPTION
  537.  *  This function is Entry function for Phonesetup->IdleScreenDisplay --> Main Menu Style
  538.  *  Following functions: HighlightPhnsetMainMenuStyleSelect
  539.  * PARAMETERS
  540.  *  void
  541.  *  a(?)        [IN/OUT]        
  542.  *  b(?)        [IN]            
  543.  * RETURNS
  544.  *  void
  545.  *****************************************************************************/
  546. void EntryPhnsetMainMenuStyle(void)
  547. {
  548.     /*----------------------------------------------------------------*/
  549.     /* Local Variables                                                */
  550.     /*----------------------------------------------------------------*/
  551.     U16 nStrItemList[MAX_SUB_MENUS];    /* Stores the strings id of submenus returned */
  552.     U16 nNumofItem;                     /* Stores no of children in the submenu */
  553.     U16 nDispAttribute;                 /* Stores display attribue */
  554.     U8 *guiBuffer;                      /* Buffer holding history data */
  556.     /*----------------------------------------------------------------*/
  557.     /* Code Body                                                      */
  558.     /*----------------------------------------------------------------*/
  559.     //S16 Err=0;
  560.     //U8 *IdleScrDispType[MAX_SUB_MENUS];
  562.     /* Call Exit Handler */
  563.     EntryNewScreen(SCR_MAINMENU_STYLE, NULL, EntryPhnsetMainMenuStyle, NULL);
  565.     /* Get current screen to gui buffer  for history purposes */
  566.     guiBuffer = GetCurrGuiBuffer(SCR_MAINMENU_STYLE);
  568.     /* Retrieve no of child of menu item to be displayed */
  569.     nNumofItem = GetNumOfChild(MENU_SETTING_MAINMENU_STYLE);
  571.     /* Get attribute of menu to be displayed */
  572.     nDispAttribute = GetDispAttributeOfItem(MENU_SETTING_MAINMENU_STYLE);
  574.     /* Retrieve string ids in sequence of given menu item to be displayed */
  575.     GetSequenceStringIds(MENU_SETTING_MAINMENU_STYLE, nStrItemList);
  577.     /* Set current parent id */
  578.     SetParentHandler(MENU_SETTING_MAINMENU_STYLE);
  580.     /* Register highlight handler to be called in menu screen */
  581.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  583.     /* Display Category Screen */
  584.     ShowCategory11Screen(
  585.         STR_MAINMENU_STYLE,
  586.         MAIN_MENU_TITLE_SETTINGS_ICON,
  587.         STR_GLOBAL_OK,
  588.         IMG_GLOBAL_OK,
  589.         STR_GLOBAL_BACK,
  590.         IMG_GLOBAL_BACK,
  591.         nNumofItem,
  592.         nStrItemList,
  593.         g_phnset_cntx_p->MenuStyle,
  594.         guiBuffer);
  596.     /* Register function with softkey */
  597.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  598.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  600. }
  603. /*****************************************************************************
  604.  * FUNCTION
  605.  *  HighlightPhnsetMainMenuStyleSelect
  606.  * DESCRIPTION
  607.  *  This function is Highlight handler for Phonesetup->IdleScreenDisplay --> Mainmenu style
  608.  *  Follow functions: PhnsetMainMenuStyleSelectLskHdlr
  609.  * PARAMETERS
  610.  *  void
  611.  *  a(?)        [IN/OUT]        
  612.  *  b(?)        [IN]            
  613.  * RETURNS
  614.  *  void
  615.  *****************************************************************************/
  616. void HighlightPhnsetMainMenuStyleSelect(void)
  617. {
  618.     /*----------------------------------------------------------------*/
  619.     /* Local Variables                                                */
  620.     /*----------------------------------------------------------------*/
  622.     /*----------------------------------------------------------------*/
  623.     /* Code Body                                                      */
  624.     /*----------------------------------------------------------------*/
  625.     /* Change right soft key icon and label */
  626.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  627.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  629.     /* Register function for left soft key */
  630.     SetLeftSoftkeyFunction(PhnsetMainMenuStyleSelectLskHdlr, KEY_EVENT_UP);
  632.     /* Register function for right soft key */
  633.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  634. }
  637. /*****************************************************************************
  638.  * FUNCTION
  639.  *  PhnsetMainMenuStyleSelectLskHdlr
  640.  * DESCRIPTION
  641.  *  This function is left softkey handling function
  642.  *  for Phonesetup->IdleScreenDisplay -> MainMenu style -> Select
  643.  *  Functionality: Save the setting menu style
  644.  * PARAMETERS
  645.  *  void
  646.  *  a(?)        [IN/OUT]        
  647.  *  b(?)        [IN]            
  648.  * RETURNS
  649.  *  void
  650.  *****************************************************************************/
  651. void PhnsetMainMenuStyleSelectLskHdlr(void)
  652. {
  653.     /*----------------------------------------------------------------*/
  654.     /* Local Variables                                                */
  655.     /*----------------------------------------------------------------*/
  656.     U8 HighlightItem = 0;
  657.     S16 Err;
  659.     /*----------------------------------------------------------------*/
  660.     /* Code Body                                                      */
  661.     /*----------------------------------------------------------------*/
  662.     HighlightItem = (U8) GetHighlightedItem();
  664.     if (g_phnset_cntx_p->MenuStyle != HighlightItem)
  665.     {
  666.         g_phnset_cntx_p->MenuStyle = HighlightItem;
  667.         WriteValue(NVRAM_SET_MAINMENU_STYLE, &(g_phnset_cntx_p->MenuStyle), DS_BYTE, &Err);
  668.     }
  670.     DisplayPopup((U8*) GetString(STR_GLOBAL_DONE), IMG_GLOBAL_ACTIVATED, 1, 2000, SUCCESS_TONE);
  671.     DeleteNScrId(SCR_MAINMENU_STYLE);
  672. }
  675. /*****************************************************************************
  676.  * FUNCTION
  677.  *  PhnsetGetMainMenuStyle
  678.  * DESCRIPTION
  679.  *  This function is to get setting main menu style
  680.  * PARAMETERS
  681.  *  void
  682.  *  a(?)        [IN/OUT]        
  683.  *  b(?)        [IN]            
  684.  * RETURNS
  685.  *  void
  686.  *****************************************************************************/
  687. U8 PhnsetGetMainMenuStyle(void)
  688. {
  689.     /*----------------------------------------------------------------*/
  690.     /* Local Variables                                                */
  691.     /*----------------------------------------------------------------*/
  693.     /*----------------------------------------------------------------*/
  694.     /* Code Body                                                      */
  695.     /*----------------------------------------------------------------*/
  696.     return g_phnset_cntx_p->MenuStyle;
  697. }
  698. #endif /* __MMI_MAINMENU_STYLE_CHANGE_EN__ */ 
  701. /*****************************************************************************
  702.  * FUNCTION
  703.  *  HighlightPhnsetShowDtTime
  704.  * DESCRIPTION
  705.  *  This function is highlight handler for Phonesetup->IdleScreenDisplay-> Show Date and Time
  706.  *  Follow functions:
  707.  * PARAMETERS
  708.  *  void
  709.  *  a(?)        [IN/OUT]        
  710.  *  b(?)        [IN]            
  711.  * RETURNS
  712.  *  void
  713.  *****************************************************************************/
  714. void HighlightPhnsetShowDtTime(void)
  715. {
  716.     /*----------------------------------------------------------------*/
  717.     /* Local Variables                                                */
  718.     /*----------------------------------------------------------------*/
  720.     /*----------------------------------------------------------------*/
  721.     /* Code Body                                                      */
  722.     /*----------------------------------------------------------------*/
  723.     /* If Show Date Time if On Show LSK as OFF otherwise On. */
  724.     if (g_phnset_cntx_p->curShowDtStatus)
  725.     {
  726.         ChangeLeftSoftkey(STR_GLOBAL_OFF, 0);
  727.     }
  728.     else
  729.     {
  730.         ChangeLeftSoftkey(STR_GLOBAL_ON, 0);
  731.     }
  733.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  735.     SetLeftSoftkeyFunction(PhnsetToggleShowDtTime, KEY_EVENT_UP);
  736.     SetKeyHandler(0, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  738.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  739.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  740. }
  743. /*****************************************************************************
  744.  * FUNCTION
  745.  *  PhnsetToggleShowDtTime
  746.  * DESCRIPTION
  747.  *  This function is Left softkey handler
  748.  *  for Phonesetup->IdleScreenDisplay-> Show Date and Time
  749.  * PARAMETERS
  750.  *  void
  751.  *  a(?)        [IN/OUT]        
  752.  *  b(?)        [IN]            
  753.  * RETURNS
  754.  *  void
  755.  *****************************************************************************/
  756. void PhnsetToggleShowDtTime(void)
  757. {
  758.     /*----------------------------------------------------------------*/
  759.     /* Local Variables                                                */
  760.     /*----------------------------------------------------------------*/
  761.     U16 index;
  763.     /*----------------------------------------------------------------*/
  764.     /* Code Body                                                      */
  765.     /*----------------------------------------------------------------*/
  766.     index = GetCurrHiliteID();
  768.     /* if show date time is on chnage it off */
  769.     if (g_phnset_cntx_p->curShowDtStatus)
  770.     {
  771.         g_phnset_cntx_p->curShowDtStatus = 0;
  772.     }
  773.     /* else chnage it on */
  774.     else
  775.     {
  776.         g_phnset_cntx_p->curShowDtStatus = 1;
  777.     }
  779.     /* Flag to Indicate Value is changed, will be used on exit Handler of menu */
  780.     g_phnset_cntx_p->ShowDtDirtyFlag = TRUE;
  782.     if (g_phnset_cntx_p->curShowDtStatus)
  783.     {
  784.         pfnUnicodeStrcpy((PS8) hintData[index], (PS8) GetString(STR_GLOBAL_ON));
  785.         Category52ChangeItemDescription(index, hintData[index]);
  786.         ChangeLeftSoftkey(STR_GLOBAL_OFF, 0);
  787.     }
  788.     else
  789.     {
  790.         pfnUnicodeStrcpy((PS8) hintData[index], (PS8) GetString(STR_GLOBAL_OFF));
  791.         Category52ChangeItemDescription(index, hintData[index]);
  792.         ChangeLeftSoftkey(STR_GLOBAL_ON, 0);
  793.     }
  795.     /* Redraw the Category Screen As Hint Handler and LSK are going to Chnage */
  796.     RedrawCategoryFunction();
  798.     /* After redraw hight the ShowDateTime */
  799.     HighlightPhnsetShowDtTime();
  800. }
  803. /*****************************************************************************
  804.  * FUNCTION
  805.  *  HighlightPhnsetShowOwnNo
  806.  * DESCRIPTION
  807.  *  This function is highlight handler for Phonesetup->IdleScreenDisplay->Show Owner Number
  808.  *  Follow functions:
  809.  * PARAMETERS
  810.  *  void
  811.  *  a(?)        [IN/OUT]        
  812.  *  b(?)        [IN]            
  813.  * RETURNS
  814.  *  void
  815.  *****************************************************************************/
  816. void HighlightPhnsetShowOwnNo(void)
  817. {
  818.     /*----------------------------------------------------------------*/
  819.     /* Local Variables                                                */
  820.     /*----------------------------------------------------------------*/
  821.     U16 index;
  823.     /*----------------------------------------------------------------*/
  824.     /* Code Body                                                      */
  825.     /*----------------------------------------------------------------*/
  826.     index = GetCurrHiliteID();
  828.     /* If Owner Number Is On Change The LSK to OFF otherwise ON. */
  829.     if (g_phnset_cntx_p->curShowOwnNumStatus == 1)
  830.     {
  831.         ChangeLeftSoftkey(STR_GLOBAL_OFF, 0);
  832.     }
  833.     else
  834.     {
  835.         ChangeLeftSoftkey(STR_GLOBAL_ON, 0);
  836.     }
  838.     /* Change right soft key icon and label */
  839.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  841.     SetLeftSoftkeyFunction(PhnsetToggleShowOwnNo, KEY_EVENT_UP);
  842.     SetKeyHandler(0, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  844.     /* Register function for right soft key */
  845.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  846.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  847. }
  850. /*****************************************************************************
  851.  * FUNCTION
  852.  *  PhnsetToggleShowOwnNo
  853.  * DESCRIPTION
  854.  *  This function is Left softkey handler
  855.  *  for Phonesetup->IdleScreenDisplay-> Show owner number
  856.  * PARAMETERS
  857.  *  void
  858.  *  a(?)        [IN/OUT]        
  859.  *  b(?)        [IN]            
  860.  * RETURNS
  861.  *  void
  862.  *****************************************************************************/
  863. void PhnsetToggleShowOwnNo(void)
  864. {
  865.     /*----------------------------------------------------------------*/
  866.     /* Local Variables                                                */
  867.     /*----------------------------------------------------------------*/
  868.     U16 index;
  870.     /*----------------------------------------------------------------*/
  871.     /* Code Body                                                      */
  872.     /*----------------------------------------------------------------*/
  873.     index = GetCurrHiliteID();
  875.     /* If Own Number Display if Off then turn it On Pressing LSK */
  876.     if (g_phnset_cntx_p->curShowOwnNumStatus == 0)
  877.     {
  878.         g_phnset_cntx_p->curShowOwnNumStatus = 1;
  879.     }
  880.     else
  881.     {
  882.         g_phnset_cntx_p->curShowOwnNumStatus = 0;
  883.     }
  885.     /* Flag to write NVRAM in Exit Handler */
  886.     g_phnset_cntx_p->ShowOwnNumDirtyFlag = TRUE;
  888.     if (g_phnset_cntx_p->curShowOwnNumStatus)
  889.     {
  890.         pfnUnicodeStrcpy((PS8) hintData[index], (PS8) GetString(STR_GLOBAL_ON));
  891.         Category52ChangeItemDescription(index, hintData[index]);
  892.         ChangeLeftSoftkey(STR_GLOBAL_OFF, 0);
  893.     }
  894.     else
  895.     {
  896.         pfnUnicodeStrcpy((PS8) hintData[index], (PS8) GetString(STR_GLOBAL_OFF));
  897.         Category52ChangeItemDescription(index, hintData[index]);
  898.         ChangeLeftSoftkey(STR_GLOBAL_ON, 0);
  899.     }
  901.     RedrawCategoryFunction();
  902.     HighlightPhnsetShowOwnNo();
  903. }
  905. /* Lisen 0921-1 */
  906. #if defined(__MMI_OPERATOR_NAME_MENU__)
  909. /*****************************************************************************
  910.  * FUNCTION
  911.  *  HighlightPhnsetShowOPN
  912.  * DESCRIPTION
  913.  *  This function is highlight handler for Phonesetup->IdleScreenDisplay->Show Operator Name
  914.  *  Follow functions:
  915.  * PARAMETERS
  916.  *  void
  917.  *  a(?)        [IN/OUT]        
  918.  *  b(?)        [IN]            
  919.  * RETURNS
  920.  *  void
  921.  *****************************************************************************/
  922. void HighlightPhnsetShowOPN(void)
  923. {
  924.     /*----------------------------------------------------------------*/
  925.     /* Local Variables                                                */
  926.     /*----------------------------------------------------------------*/
  927.     U16 index;
  929.     /*----------------------------------------------------------------*/
  930.     /* Code Body                                                      */
  931.     /*----------------------------------------------------------------*/
  932.     index = GetCurrHiliteID();
  934.     /* If Owner Number Is On Change The LSK to OFF otherwise ON. */
  935.     if (g_phnset_cntx_p->curShowOPNStatus == 1)
  936.     {
  937.         ChangeLeftSoftkey(STR_GLOBAL_OFF, 0);
  938.     }
  939.     else
  940.     {
  941.         ChangeLeftSoftkey(STR_GLOBAL_ON, 0);
  942.     }
  944.     /* Change right soft key icon and label */
  945.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  947.     SetLeftSoftkeyFunction(PhnsetToggleShowOPN, KEY_EVENT_UP);
  948.     SetKeyHandler(0, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  950.     /* Register function for right soft key */
  951.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  952.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  953. }
  956. /*****************************************************************************
  957.  * FUNCTION
  958.  *  PhnsetToggleShowOPN
  959.  * DESCRIPTION
  960.  *  This function is Left softkey handler
  961.  *  for Phonesetup->IdleScreenDisplay-> Show Operator Name
  962.  * PARAMETERS
  963.  *  void
  964.  *  a(?)        [IN/OUT]        
  965.  *  b(?)        [IN]            
  966.  * RETURNS
  967.  *  void
  968.  *****************************************************************************/
  969. void PhnsetToggleShowOPN(void)
  970. {
  971.     /*----------------------------------------------------------------*/
  972.     /* Local Variables                                                */
  973.     /*----------------------------------------------------------------*/
  974.     U16 index;
  976.     /*----------------------------------------------------------------*/
  977.     /* Code Body                                                      */
  978.     /*----------------------------------------------------------------*/
  979.     index = GetCurrHiliteID();
  981.     /* If Own Number Display if Off then turn it On Pressing LSK */
  982.     if (g_phnset_cntx_p->curShowOPNStatus == 0)
  983.     {
  984.         g_phnset_cntx_p->curShowOPNStatus = 1;
  985.     }
  986.     else
  987.     {
  988.         g_phnset_cntx_p->curShowOPNStatus = 0;
  989.     }
  991.     /* Flag to write NVRAM in Exit Handler */
  992.     g_phnset_cntx_p->ShowOPNDirtyFlag = TRUE;
  994.     if (g_phnset_cntx_p->curShowOPNStatus)
  995.     {
  996.         pfnUnicodeStrcpy((PS8) hintData[index], (PS8) GetString(STR_GLOBAL_ON));
  997.         Category52ChangeItemDescription(index, hintData[index]);
  998.         ChangeLeftSoftkey(STR_GLOBAL_OFF, 0);
  999.     }
  1000.     else
  1001.     {
  1002.         pfnUnicodeStrcpy((PS8) hintData[index], (PS8) GetString(STR_GLOBAL_OFF));
  1003.         Category52ChangeItemDescription(index, hintData[index]);
  1004.         ChangeLeftSoftkey(STR_GLOBAL_ON, 0);
  1005.     }
  1007.     RedrawCategoryFunction();
  1008.     HighlightPhnsetShowOPN();
  1009. }
  1010. #endif /* defined(__MMI_OPERATOR_NAME_MENU__) */ 
  1013. /*****************************************************************************
  1014.  * FUNCTION
  1015.  *  PhnsetSetShowDTStatus
  1016.  * DESCRIPTION
  1017.  *  This function is to set show data time statu on/off
  1018.  *  Follow functions:
  1019.  * PARAMETERS
  1020.  *  status      [IN]            
  1021.  *  a(?)        [IN/OUT]        
  1022.  *  b(?)        [IN]            
  1023.  * RETURNS
  1024.  *  void
  1025.  *****************************************************************************/
  1026. void PhnsetSetShowDTStatus(U8 status)
  1027. {
  1028.     /*----------------------------------------------------------------*/
  1029.     /* Local Variables                                                */
  1030.     /*----------------------------------------------------------------*/
  1032.     /*----------------------------------------------------------------*/
  1033.     /* Code Body                                                      */
  1034.     /*----------------------------------------------------------------*/
  1035.     g_phnset_cntx_p->curShowDtStatus = status;
  1036. }
  1038. /*
  1039.  * ( Phonesetup-> SpeedDial -> Set Number ) functions are in speedDial.c
  1040.  */
  1044. /*****************************************************************************
  1045.  * FUNCTION
  1046.  *  HighlightPhnsetWelcomeText
  1047.  * DESCRIPTION
  1048.  *  This function is highlight handler for Phonesetup-> Greeting Text
  1049.  *  Follow functions:
  1050.  * PARAMETERS
  1051.  *  void
  1052.  *  a(?)        [IN/OUT]        
  1053.  *  b(?)        [IN]            
  1054.  * RETURNS
  1055.  *  void
  1056.  *****************************************************************************/
  1057. void HighlightPhnsetWelcomeText(void)
  1058. {
  1059.     /*----------------------------------------------------------------*/
  1060.     /* Local Variables                                                */
  1061.     /*----------------------------------------------------------------*/
  1063.     /*----------------------------------------------------------------*/
  1064.     /* Code Body                                                      */
  1065.     /*----------------------------------------------------------------*/
  1066.     /* Change left soft key icon and label */
  1067.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  1069.     /* Change right soft key icon and label */
  1070.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  1072.     /* Register function for left soft key */
  1073.     SetLeftSoftkeyFunction(EntryPhnsetWelcomeText, KEY_EVENT_UP);
  1074.     SetKeyHandler(EntryPhnsetWelcomeText, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1076.     /* Register function for right soft key */
  1077.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1078.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1079. }
  1082. /*****************************************************************************
  1083.  * FUNCTION
  1084.  *  PhnsetFillWelcomeInlineEditStruct
  1085.  * DESCRIPTION
  1086.  *  This function is to fill inline editor screen for Phonesetup-> Greeting Text
  1087.  * PARAMETERS
  1088.  *  pInlineStruct       [?]             
  1089.  *  a(?)                [IN/OUT]        
  1090.  *  b(?)                [IN]            
  1091.  * RETURNS
  1092.  *  void
  1093.  *****************************************************************************/
  1094. static void PhnsetFillWelcomeInlineEditStruct(void *pInlineStruct)
  1095. {
  1096.     /*----------------------------------------------------------------*/
  1097.     /* Local Variables                                                */
  1098.     /*----------------------------------------------------------------*/
  1099.     S8 *WelcomeString = NULL;
  1100.     InlineItem *InlineStruct = (InlineItem*) pInlineStruct;
  1102.     /*----------------------------------------------------------------*/
  1103.     /* Code Body                                                      */
  1104.     /*----------------------------------------------------------------*/
  1105.     WelcomeString = GetWelcomeText();
  1106.     /* CurrSelect */
  1107.     g_phnset_cntx_p->curHightlightItem = (U32) IsShowWelcomeScr1();
  1109.     pfnUnicodeStrncpy((S8*) WelcomeText, WelcomeString, MAX_SETTING_WELCOME_TEXT);
  1110.     OslMfree(WelcomeString);
  1112.     greet_text_on_off[1] = (U8*) GetString(STR_GLOBAL_ON);
  1113.     greet_text_on_off[0] = (U8*) GetString(STR_GLOBAL_OFF);
  1115.     SetInlineItemActivation(&InlineStruct[0], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  1116.     SetInlineItemCaption(&InlineStruct[0], (PU8) (U8*) GetString(STR_MENU9146_OFF));
  1118.     SetInlineItemActivation(&InlineStruct[2], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  1119.     SetInlineItemCaption(&InlineStruct[2], (PU8) (U8*) GetString(STR_MENU9146_ON));
  1121.     SetInlineItemActivation(&InlineStruct[1], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  1122.     SetInlineItemSelect(
  1123.         &InlineStruct[1],
  1124.         2,
  1125.         greet_text_on_off,
  1126.         (S32*) & (g_phnset_cntx_p->curHightlightItem) /* CurrSelect */ );
  1128.     SetInlineItemActivation(&InlineStruct[3], KEY_LSK, KEY_EVENT_UP);
  1129.     /* disable new line */
  1130.     SetInlineItemFullScreenEdit_ext(
  1131.         &InlineStruct[3],
  1132.         STR_MENU9146_WELCOME_TEXT,
  1133.         MAIN_MENU_TITLE_SETTINGS_ICON,
  1134.         (PU8) WelcomeText,
  1135.         MAX_SETTING_WELCOME_TEXT + 1,
  1136.         INPUT_TYPE_ALPHANUMERIC_SENTENCECASE,
  1137.         INPUT_TYPE_EXT_NO_SHOW_NEW_LINE_SYMBOL);
  1139.     SetInlineFullScreenEditCustomFunction(&InlineStruct[3], SettingInlineCustomFunction);
  1141. }
  1144. /*****************************************************************************
  1145.  * FUNCTION
  1146.  *  EntryPhnsetWelcomeText
  1147.  * DESCRIPTION
  1148.  *  This function is Entry function for Phonesetup-> Greeting Text
  1149.  *  Following functions: EntryWelcomeTextOn
  1150.  * PARAMETERS
  1151.  *  void
  1152.  *  a(?)        [IN/OUT]        
  1153.  *  b(?)        [IN]            
  1154.  * RETURNS
  1155.  *  void
  1156.  *****************************************************************************/
  1157. void EntryPhnsetWelcomeText(void)
  1158. {
  1159.     /*----------------------------------------------------------------*/
  1160.     /* Local Variables                                                */
  1161.     /*----------------------------------------------------------------*/
  1162.     U16 nNumofItem = 4; /* Stores no of children in the submenu */
  1163.     U8 *inputBuffer;    /* added for inline edit history */
  1164.     U8 *guiBuffer;      /* Buffer holding history data */
  1165.     U16 inputBufferSize;
  1166.     U16 ItemIcons[4] = {IMG_SETTING_GREET_STATUS, 0, IMG_SETTING_GREET_TEXT, 0};
  1167.     InlineItem greet_text_inline_edit_list[4];
  1169.     /*----------------------------------------------------------------*/
  1170.     /* Code Body                                                      */
  1171.     /*----------------------------------------------------------------*/
  1172.     EntryNewScreen(SCR9146_WELCOME_TEXT, ExitPhnsetWelcomeText, NULL, NULL);
  1174.     guiBuffer = GetCurrGuiBuffer(SCR9146_WELCOME_TEXT);
  1176.     InitializeCategory57Screen();
  1177.     memset(greet_text_inline_edit_list, 0, sizeof(greet_text_inline_edit_list));
  1178.     PhnsetFillWelcomeInlineEditStruct((void*)greet_text_inline_edit_list);
  1179.     inputBuffer = GetCurrNInputBuffer(SCR9146_WELCOME_TEXT, &inputBufferSize);  /* added for inline edit history */
  1180.     if (inputBuffer != NULL)
  1181.     {
  1182.         SetCategory57Data(greet_text_inline_edit_list, nNumofItem, inputBuffer);
  1183.     }
  1185.     ClearHighlightHandler();
  1187.     ShowCategory57Screen(
  1188.         STR_MENU9146_WELCOME_TEXT,
  1189.         MAIN_MENU_TITLE_SETTINGS_ICON,
  1190.         STR_GLOBAL_OK,
  1191.         IMG_GLOBAL_OK,
  1192.         STR_GLOBAL_BACK,
  1193.         IMG_GLOBAL_BACK,
  1194.         nNumofItem,
  1195.         ItemIcons,
  1196.         greet_text_inline_edit_list,
  1197.         0,
  1198.         guiBuffer);
  1200.     /* Register function for right soft key */
  1201.     SetCategory57RightSoftkeyFunctions(EntryPhnsetWelcomeTextDoneHdlr, GoBackHistory);
  1203. }
  1206. /*****************************************************************************
  1207.  * FUNCTION
  1208.  *  ExitPhnsetWelcomeText
  1209.  * DESCRIPTION
  1210.  *  This function is Exit function for Phonesetup-> Greeting Text
  1211.  *  Following functions:
  1212.  * PARAMETERS
  1213.  *  void
  1214.  *  a(?)        [IN/OUT]        
  1215.  *  b(?)        [IN]            
  1216.  * RETURNS
  1217.  *  void
  1218.  *****************************************************************************/
  1219. void ExitPhnsetWelcomeText(void)
  1220. {
  1221.     /*----------------------------------------------------------------*/
  1222.     /* Local Variables                                                */
  1223.     /*----------------------------------------------------------------*/
  1224.     history Scr;
  1225.     S16 nHistory = 0;
  1226.     U16 inputBufferSize;    /* added for inline edit history */
  1228.     /*----------------------------------------------------------------*/
  1229.     /* Code Body                                                      */
  1230.     /*----------------------------------------------------------------*/
  1231.     Scr.scrnID = SCR9146_WELCOME_TEXT;
  1232.     CloseCategory57Screen();
  1233.     Scr.entryFuncPtr = EntryPhnsetWelcomeText;
  1234.     pfnUnicodeStrcpy((S8*) Scr.inputBuffer, (S8*) & nHistory);
  1235.     GetCategory57History(Scr.guiBuffer);
  1236.     inputBufferSize = (U16) GetCategory57DataSize();    /* added for inline edit history */
  1237.     GetCategory57Data((U8*) Scr.inputBuffer);           /* added for inline edit history */
  1238.     AddNHistory(Scr, (U16) inputBufferSize);            /* added for inline edit history */
  1239. }
  1242. /*****************************************************************************
  1243.  * FUNCTION
  1244.  *  EntryPhnsetWelcomeTextDoneHdlr
  1245.  * DESCRIPTION
  1246.  *  This function is done key handler  for Phonesetup-> Greeting Text -> Done
  1247.  *  Functionality: Query Yes/No
  1248.  *  Following functions:  PhnsetWelcomeTextDoneLskHdlr
  1249.  * PARAMETERS
  1250.  *  void
  1251.  *  a(?)        [IN/OUT]        
  1252.  *  b(?)        [IN]            
  1253.  * RETURNS
  1254.  *  void
  1255.  *****************************************************************************/
  1256. void EntryPhnsetWelcomeTextDoneHdlr(void)
  1257. {
  1258.     /*----------------------------------------------------------------*/
  1259.     /* Local Variables                                                */
  1260.     /*----------------------------------------------------------------*/
  1261.     U8 *guiBuffer;  /* Buffer holding history data */
  1263.     /*----------------------------------------------------------------*/
  1264.     /* Code Body                                                      */
  1265.     /*----------------------------------------------------------------*/
  1266.     /* Call Exit Handler */
  1267.     EntryNewScreen(SCR9146_WELCOME_TEXT_ON, NULL, NULL, NULL);
  1269.     /* Get current screen to gui buffer  for history purposes */
  1270.     guiBuffer = GetCurrGuiBuffer(SCR9146_WELCOME_TEXT_ON);
  1272.     /* Display Category1 Screen */
  1273.     DisplayConfirm(
  1274.         STR_GLOBAL_YES,
  1275.         IMG_GLOBAL_YES,
  1276.         STR_GLOBAL_NO,
  1277.         IMG_GLOBAL_NO,
  1278.         (PU16) GetString(STR_GLOBAL_SAVE),
  1279.         IMG_GLOBAL_QUESTION,
  1280.         WARNING_TONE);
  1281.     
  1282.     SetLeftSoftkeyFunction(PhnsetWelcomeTextDoneLskHdlr, KEY_EVENT_UP);
  1283.     SetRightSoftkeyFunction(GoBack2TheHistory, KEY_EVENT_UP);
  1285.     /* Play warning tone */
  1286.     playRequestedTone(WARNING_TONE);
  1287. }
  1290. /*****************************************************************************
  1291.  * FUNCTION
  1292.  *  PhnsetWelcomeTextDoneLskHdlr
  1293.  * DESCRIPTION
  1294.  *  This function is Left softkey handler
  1295.  *  for Phonesetup-> Greeting Text -> Done -> Yes
  1296.  * PARAMETERS
  1297.  *  void
  1298.  *  a(?)        [IN/OUT]        
  1299.  *  b(?)        [IN]            
  1300.  * RETURNS
  1301.  *  void
  1302.  *****************************************************************************/
  1303. void PhnsetWelcomeTextDoneLskHdlr(void)
  1304. {
  1305.     /*----------------------------------------------------------------*/
  1306.     /* Local Variables                                                */
  1307.     /*----------------------------------------------------------------*/
  1308.     S16 error;
  1310.     /*----------------------------------------------------------------*/
  1311.     /* Code Body                                                      */
  1312.     /*----------------------------------------------------------------*/
  1313.     /* ExecuteCurrExitHandler(); */
  1315.     ClearInputEventHandler(MMI_DEVICE_ALL);
  1316.     ClearKeyHandler(KEY_END, KEY_EVENT_DOWN);
  1318.     WriteValue(
  1319.         NVRAM_SETTING_WELCOME_TEXT,
  1320.         (U8*) & (g_phnset_cntx_p->curHightlightItem) /* CurrSelect */ ,
  1321.         DS_BYTE,
  1322.         &error);
  1323.     WriteRecord(
  1324.         NVRAM_EF_SETTING_LID,
  1325.         1,
  1326.         (void*)WelcomeText,
  1327.         (U16) (MAX_SETTING_WELCOME_TEXT * ENCODING_LENGTH),
  1328.         &error);
  1330. #if 0
  1331. /* under construction !*/
  1332. /* under construction !*/
  1333. /* under construction !*/
  1334. /* under construction !*/
  1335. /* under construction !*/
  1336. /* under construction !*/
  1337. /* under construction !*/
  1338. /* under construction !*/
  1339. /* under construction !*/
  1340. /* under construction !*/
  1341. /* under construction !*/
  1342. /* under construction !*/
  1343. /* under construction !*/
  1344. /* under construction !*/
  1345. /* under construction !*/
  1346. /* under construction !*/
  1347. #endif /* 0 */ 
  1349.     DisplayPopup((PU8) GetString(STR_GLOBAL_DONE), IMG_GLOBAL_ACTIVATED, 1, ST_NOTIFYDURATION, SUCCESS_TONE);
  1350.     DeleteNHistory(1);
  1352. }
  1355. /*****************************************************************************
  1356.  * FUNCTION
  1357.  *  HighlightSPOF
  1358.  * DESCRIPTION
  1359.  *  This function is Highlight handler for Phonesetup->IdleScreenDisplay --> Mainmenu style
  1360.  *  Follow functions: EntryPhnsetMainMenuStyle
  1361.  * PARAMETERS
  1362.  *  void
  1363.  *  a(?)        [IN/OUT]        
  1364.  *  b(?)        [IN]            
  1365.  * RETURNS
  1366.  *  void
  1367.  *****************************************************************************/
  1368. void HighlightSPOF(void)
  1369. {
  1370.     /*----------------------------------------------------------------*/
  1371.     /* Local Variables                                                */
  1372.     /*----------------------------------------------------------------*/
  1374.     /*----------------------------------------------------------------*/
  1375.     /* Code Body                                                      */
  1376.     /*----------------------------------------------------------------*/
  1377.     /* 1 Change left soft key icon and label */
  1378.     ChangeLeftSoftkey(STR_GLOBAL_OK, 0);
  1380.     /* 2 Change right soft key icon and label */
  1381.     ChangeRightSoftkey(STR_GLOBAL_BACK, 0);
  1383.     /* 3 Register function for left soft key */
  1384. #ifdef MMI_ON_HARDWARE_P
  1385.     SetLeftSoftkeyFunction(EntrySpofApp, KEY_EVENT_UP);
  1386.     SetKeyHandler(EntrySpofApp, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1387. #else /* MMI_ON_HARDWARE_P */ 
  1388.     SetLeftSoftkeyFunction(PopupNoSupport, KEY_EVENT_UP);
  1389.     SetKeyHandler(PopupNoSupport, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1390. #endif /* MMI_ON_HARDWARE_P */ 
  1392.     /* 4 Register function for right soft key */
  1393.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1394.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1395. }
  1397. /*
  1398.  * ( Phonesetup-> SPOF ) functions are in ScheduledPowerOnOff.c
  1399.  */
  1401. /*
  1402.  * Query function begin:
  1403.  */
  1406. /*****************************************************************************
  1407.  * FUNCTION
  1408.  *  PhnsetGetShowOwnerNumStatus
  1409.  * DESCRIPTION
  1410.  *  This function is to get show owner number on/off status
  1411.  *  Functionality:
  1412.  * PARAMETERS
  1413.  *  void
  1414.  *  a(?)        [IN/OUT]        
  1415.  *  b(?)        [IN]            
  1416.  * RETURNS
  1417.  *  void
  1418.  *****************************************************************************/
  1419. MMI_BOOL PhnsetGetShowOwnerNumStatus(void)
  1420. {
  1421.     /*----------------------------------------------------------------*/
  1422.     /* Local Variables                                                */
  1423.     /*----------------------------------------------------------------*/
  1424.     U8 data = 0;
  1425.     S16 error;
  1427.     /*----------------------------------------------------------------*/
  1428.     /* Code Body                                                      */
  1429.     /*----------------------------------------------------------------*/
  1430.     ReadValue(NVRAM_SETTING_OWNER_NO, &data, DS_BYTE, &error);
  1432.     if (data == 1)
  1433.     {
  1434.         return MMI_TRUE;
  1435.     }
  1436.     else
  1437.     {
  1438.         return MMI_FALSE;
  1439.     }
  1440. }
  1442. /* Lisen 0921-1 */
  1443. #if defined(__MMI_OPERATOR_NAME_MENU__)
  1446. /*****************************************************************************
  1447.  * FUNCTION
  1448.  *  PhnsetGetShowOPNStatus
  1449.  * DESCRIPTION
  1450.  *  This function is to get show owner number on/off status
  1451.  *  Functionality:
  1452.  * PARAMETERS
  1453.  *  void
  1454.  *  a(?)        [IN/OUT]        
  1455.  *  b(?)        [IN]            
  1456.  * RETURNS
  1457.  *  void
  1458.  *****************************************************************************/
  1459. MMI_BOOL PhnsetGetShowOPNStatus(void)
  1460. {
  1461.     /*----------------------------------------------------------------*/
  1462.     /* Local Variables                                                */
  1463.     /*----------------------------------------------------------------*/
  1464.     U8 data = 0;
  1465.     S16 error;
  1467.     /*----------------------------------------------------------------*/
  1468.     /* Code Body                                                      */
  1469.     /*----------------------------------------------------------------*/
  1470.     ReadValue(NVRAM_SETTING_OPN_DISPLAY, &data, DS_BYTE, &error);
  1472.     if (data == 0)
  1473.     {
  1474.         return MMI_FALSE;
  1475.     }
  1476.     else
  1477.     {
  1478.         return MMI_TRUE;
  1479.     }
  1480. }
  1481. #endif /* defined(__MMI_OPERATOR_NAME_MENU__) */ 
  1484. /*****************************************************************************
  1485.  * FUNCTION
  1486.  *  PhnsetGetShowDateTimeStatus
  1487.  * DESCRIPTION
  1488.  *  This function is to get show date/time on/off status
  1489.  *  Functionality:
  1490.  * PARAMETERS
  1491.  *  void
  1492.  *  a(?)        [IN/OUT]        
  1493.  *  b(?)        [IN]            
  1494.  * RETURNS
  1495.  *  void
  1496.  *****************************************************************************/
  1497. MMI_BOOL PhnsetGetShowDateTimeStatus(void)
  1498. {
  1499.     /*----------------------------------------------------------------*/
  1500.     /* Local Variables                                                */
  1501.     /*----------------------------------------------------------------*/
  1502.     U8 data = 0;
  1503.     S16 error;
  1505.     /*----------------------------------------------------------------*/
  1506.     /* Code Body                                                      */
  1507.     /*----------------------------------------------------------------*/
  1508.     ReadValue(NVRAM_SETTING_STATUS_DT_TIME, &data, DS_BYTE, &error);
  1510.     if (data == 0)
  1511.     {
  1512.         return MMI_FALSE;
  1513.     }
  1514.     else
  1515.     {
  1516.         return MMI_TRUE;
  1517.     }
  1518. }
  1521. /*****************************************************************************
  1522.  * FUNCTION
  1523.  *  PhnsetSetWelcomeText
  1524.  * DESCRIPTION
  1525.  *  This function is to set welcome text for AT command
  1526.  *  Functionality:
  1527.  * PARAMETERS
  1528.  *  mode        [IN]            
  1529.  *  dcs         [IN]            
  1530.  *  text        [?]             
  1531.  *  a(?)        [IN/OUT]        
  1532.  *  b(?)        [IN]            
  1533.  * RETURNS
  1534.  *  void
  1535.  *****************************************************************************/
  1536. MMI_BOOL PhnsetSetWelcomeText(MMI_BOOL mode, U8 dcs, U8 *text, U8 length)
  1537. {
  1538.     /*----------------------------------------------------------------*/
  1539.     /* Local Variables                                                */
  1540.     /*----------------------------------------------------------------*/
  1541.     S16 error;
  1542.     S32 AtMode;
  1544.     /*----------------------------------------------------------------*/
  1545.     /* Code Body                                                      */
  1546.     /*----------------------------------------------------------------*/
  1547.     if (length != 0xFF)
  1548.     {
  1549.         U8 AtWelcomeText[(MAX_SETTING_WELCOME_TEXT + 1) * ENCODING_LENGTH];
  1551.         memset(AtWelcomeText, 0, sizeof(AtWelcomeText));
  1552.         if (dcs == L4_ASCII)
  1553.         {
  1554.             AnsiiNToUnicodeString((S8*) AtWelcomeText, (S8*) text, MAX_SETTING_WELCOME_TEXT);
  1555.         }
  1556.         else if (dcs == L4_UCS2)
  1557.         {
  1558.             memcpy(AtWelcomeText, text, sizeof(AtWelcomeText));
  1559.         }
  1561.         WriteRecord(
  1562.             NVRAM_EF_SETTING_LID,
  1563.             1,
  1564.             (void*)AtWelcomeText,
  1565.             (U16) (MAX_SETTING_WELCOME_TEXT * ENCODING_LENGTH),
  1566.             &error);
  1567.             
  1568.         if (error != NVRAM_WRITE_SUCCESS)
  1569.         {
  1570.             return MMI_FALSE;
  1571.         }
  1572.     }
  1574.     if (mode == 0)
  1575.     {
  1576.         AtMode = 0;
  1577.     }
  1578.     else
  1579.     {
  1580.         AtMode = 1;
  1581.     }
  1583.     WriteValue(NVRAM_SETTING_WELCOME_TEXT, (U8*) & AtMode, DS_BYTE, &error);
  1585.     if (error != NVRAM_WRITE_SUCCESS)
  1586.     {
  1587.         return MMI_FALSE;
  1588.     }
  1590.     return MMI_TRUE;
  1592. }
  1595. /*****************************************************************************
  1596.  * FUNCTION
  1597.  *  PhnsetGetWelcomeText
  1598.  * DESCRIPTION
  1599.  *  This function is to get welcome text for AT command
  1600.  *  Functionality:
  1601.  * PARAMETERS
  1602.  *  buf             [?]             
  1603.  *  buf_size        [IN]            
  1604.  *  a(?)            [IN/OUT]        
  1605.  *  b(?)            [IN]            
  1606.  * RETURNS
  1607.  *  void
  1608.  *****************************************************************************/
  1609. void PhnsetGetWelcomeText(S8 *buf, U16 buf_size)
  1610. {
  1611.     /*----------------------------------------------------------------*/
  1612.     /* Local Variables                                                */
  1613.     /*----------------------------------------------------------------*/
  1614.     S16 error;
  1615.     U8 data[(MAX_SETTING_WELCOME_TEXT + 1) * ENCODING_LENGTH];
  1616.     U16 max_buf_size;
  1618.     /*----------------------------------------------------------------*/
  1619.     /* Code Body                                                      */
  1620.     /*----------------------------------------------------------------*/
  1621.     memset(data, 0, sizeof(data));
  1622.     ReadRecord(NVRAM_EF_SETTING_LID, 1, data, (MAX_SETTING_WELCOME_TEXT * ENCODING_LENGTH), &error);
  1624.     if (buf_size < (MAX_SETTING_WELCOME_TEXT + 1) * ENCODING_LENGTH)
  1625.     {
  1626.         max_buf_size = buf_size;
  1627.     }
  1628.     else
  1629.     {
  1630.         max_buf_size = (MAX_SETTING_WELCOME_TEXT + 1) * ENCODING_LENGTH;
  1631.     }
  1633.     memset(buf, 0, buf_size);
  1634.     if (data[0] != 0xFF)
  1635.     {
  1636.         memcpy(buf, data, (max_buf_size - ENCODING_LENGTH));
  1637.     }
  1639. }
  1642. /*
  1643.  * Hint Handler begin:
  1644.  */
  1647. /*****************************************************************************
  1648.  * FUNCTION
  1649.  *  HintPhnsetLanguage
  1650.  * DESCRIPTION
  1651.  *  This function is hint handling function
  1652.  *  for Phonesetup -> Language
  1653.  *  Functionality:
  1654.  * PARAMETERS
  1655.  *  index       [IN]            
  1656.  *  a(?)        [IN/OUT]        
  1657.  *  b(?)        [IN]            
  1658.  * RETURNS
  1659.  *  void
  1660.  *****************************************************************************/
  1661. void HintPhnsetLanguage(U16 index)
  1662. {
  1663.     /*----------------------------------------------------------------*/
  1664.     /* Local Variables                                                */
  1665.     /*----------------------------------------------------------------*/
  1666.     S16 error;
  1667.     U8 data = 0;
  1669.     /*----------------------------------------------------------------*/
  1670.     /* Code Body                                                      */
  1671.     /*----------------------------------------------------------------*/
  1672.     ReadValue(NVRAM_SETTING_LANG, &data, DS_BYTE, &error);
  1674. #ifdef __MMI_AUTO_LANG_EN__
  1675.     if (data == 0xFF)   /* Auto Language Selected */
  1676.     {
  1677.         pfnUnicodeStrcpy((PS8) hintData[index], (PS8) GetString(STR_LANGUAGESCR_AUTO));
  1678.     }
  1679.     else
  1680. #endif /* __MMI_AUTO_LANG_EN__ */ 
  1681.     {
  1682.         pfnUnicodeStrcpy((PS8) hintData[index], (PS8) gLanguageArray[data].aName);
  1683.     }
  1685. }
  1688. /*****************************************************************************
  1689.  * FUNCTION
  1690.  *  HintPhnsetPreferedInputMethod
  1691.  * DESCRIPTION
  1692.  *  This function is hint handling function
  1693.  *  for Phonesetup -> Language
  1694.  *  Functionality:
  1695.  * PARAMETERS
  1696.  *  index       [IN]            
  1697.  *  a(?)        [IN/OUT]        
  1698.  *  b(?)        [IN]            
  1699.  * RETURNS
  1700.  *  void
  1701.  *****************************************************************************/
  1702. #ifdef __MMI_PREFER_INPUT_METHOD__
  1703. void HintPhnsetPreferedInputMethod(U16 index)
  1704. {
  1705.     /*----------------------------------------------------------------*/
  1706.     /* Local Variables                                                */
  1707.     /*----------------------------------------------------------------*/
  1708.     S16 error;
  1709.     U16 data = 0;
  1711.     /*----------------------------------------------------------------*/
  1712.     /* Code Body                                                      */
  1713.     /*----------------------------------------------------------------*/
  1714.     ReadValue(NVRAM_SETTING_PREFER_INPUT_METHOD, &data, DS_SHORT, &error);
  1715.     InitPreferedInputMethod();
  1716.     pfnUnicodeStrcpy((PS8) hintData[index], (PS8) inputMethodList[GetInputMethodIndex(data)]);
  1717. }
  1718. #endif /* __MMI_PREFER_INPUT_METHOD__ */ 
  1720. #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  1723. /*****************************************************************************
  1724.  * FUNCTION
  1725.  *  HighlightHandwritingSetting
  1726.  * DESCRIPTION
  1727.  *  This function is highlight handler for Handwriting setting screen
  1728.  * PARAMETERS
  1729.  *  void
  1730.  * RETURNS
  1731.  *  void
  1732.  *****************************************************************************/
  1733. void HighlightHandwritingSetting(void)
  1734. {
  1735.     /*----------------------------------------------------------------*/
  1736.     /* Local Variables                                                */
  1737.     /*----------------------------------------------------------------*/
  1739.     /*----------------------------------------------------------------*/
  1740.     /* Code Body                                                      */
  1741.     /*----------------------------------------------------------------*/
  1742.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  1743.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  1744.     SetLeftSoftkeyFunction(EntryHandWritingSettingScr, KEY_EVENT_UP);
  1745.     SetKeyHandler(EntryHandWritingSettingScr, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1746.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1747.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1748. }
  1751. /*****************************************************************************
  1752.  * FUNCTION
  1753.  *  HighlightCalibrationSetting
  1754.  * DESCRIPTION
  1755.  *  This function is highlight handler for Calibration setting screen
  1756.  * PARAMETERS
  1757.  *  void
  1758.  * RETURNS
  1759.  *  void
  1760.  *****************************************************************************/
  1761. void HighlightCalibrationSetting(void)
  1762. {
  1763.     /*----------------------------------------------------------------*/
  1764.     /* Local Variables                                                */
  1765.     /*----------------------------------------------------------------*/
  1767.     /*----------------------------------------------------------------*/
  1768.     /* Code Body                                                      */
  1769.     /*----------------------------------------------------------------*/
  1770.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  1771.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  1772.     SetLeftSoftkeyFunction(EntryCalibrationSettingScr, KEY_EVENT_UP);
  1773.     SetKeyHandler(EntryCalibrationSettingScr, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  1774.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1775.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  1776. }
  1779. /*****************************************************************************
  1780.  * FUNCTION
  1781.  *  SaveHandwritingSetting
  1782.  * DESCRIPTION
  1783.  *  This function saves pen setting in Settings->PhoneSetup->PenSetting screen
  1784.  *  Functionality:
  1785.  * PARAMETERS
  1786.  *  void
  1787.  * RETURNS
  1788.  *  void
  1789.  *****************************************************************************/
  1790. void SaveHandwritingSetting(void)
  1791. {
  1792.     /*----------------------------------------------------------------*/
  1793.     /* Local Variables                                                */
  1794.     /*----------------------------------------------------------------*/
  1795.     S16 pError;
  1797.     /*----------------------------------------------------------------*/
  1798.     /* Code Body                                                      */
  1799.     /*----------------------------------------------------------------*/
  1800.     g_phnset_cntx_p->pen_speed = gInlinePenSpeed;
  1801.     g_phnset_cntx_p->pen_color = gInlinePenColorIndex;
  1803.     WriteValue(NVRAM_PEN_SPEED, &(g_phnset_cntx_p->pen_speed), DS_BYTE, &pError);
  1804.     if (pError != NVRAM_WRITE_SUCCESS)
  1805.     {
  1806.         PRINT_INFORMATION(("NVRAM PenSetting Write Failed. Error -%d", pError));
  1807.     }
  1808.     WriteValue(NVRAM_PEN_COLOR, &(g_phnset_cntx_p->pen_color), DS_BYTE, &pError);
  1809.     if (pError != NVRAM_WRITE_SUCCESS)
  1810.     {
  1811.         PRINT_INFORMATION(("NVRAM Pen Setting Write Failed. Error -%d", pError));
  1812.     }
  1814.     GoBeyondMarkerScr(SCR_HANDWRITING_SETTING);
  1815. }
  1818. /*****************************************************************************
  1819.  * FUNCTION
  1820.  *  GoBackHandwritingSettingConfirm
  1821.  * DESCRIPTION
  1822.  *  This function exits pen setting screen when user doesn't save pen settings after changing in Settings->PhoneSetup->PenSetting screen
  1823.  *  Functionality:
  1824.  * PARAMETERS
  1825.  *  void
  1826.  * RETURNS
  1827.  *  void
  1828.  *****************************************************************************/
  1829. void GoBackHandwritingSettingConfirm(void)
  1830. {
  1831.     /*----------------------------------------------------------------*/
  1832.     /* Local Variables                                                */
  1833.     /*----------------------------------------------------------------*/
  1835.     /*----------------------------------------------------------------*/
  1836.     /* Code Body                                                      */
  1837.     /*----------------------------------------------------------------*/
  1838.     GoBeyondMarkerScr(SCR_HANDWRITING_SETTING);
  1839. }
  1842. /*****************************************************************************
  1843.  * FUNCTION
  1844.  *  EntryScrHandwritingSettingConfirm
  1845.  * DESCRIPTION
  1846.  *  This function displays pop up to confirm pen settings change before saving them in Settings->PhoneSetup->PenSetting screen
  1847.  *  Functionality:
  1848.  * PARAMETERS
  1849.  *  void
  1850.  *  a(?)        [IN/OUT]        
  1851.  *  b(?)        [IN]            
  1852.  * RETURNS
  1853.  *  void
  1854.  *****************************************************************************/
  1855. void EntryScrHandwritingSettingConfirm(void)
  1856. {
  1857.     /*----------------------------------------------------------------*/
  1858.     /* Local Variables                                                */
  1859.     /*----------------------------------------------------------------*/
  1861.     /*----------------------------------------------------------------*/
  1862.     /* Code Body                                                      */
  1863.     /*----------------------------------------------------------------*/
  1864.     DisplayConfirm(
  1865.         STR_GLOBAL_YES,
  1866.         IMG_GLOBAL_YES,
  1867.         STR_GLOBAL_NO,
  1868.         IMG_GLOBAL_NO,
  1869.         get_string(STR_GLOBAL_SAVE),
  1870.         IMG_GLOBAL_QUESTION,
  1871.         WARNING_TONE);
  1873.     SetLeftSoftkeyFunction(SaveHandwritingSetting, KEY_EVENT_UP);
  1874.     SetRightSoftkeyFunction(GoBackHandwritingSettingConfirm, KEY_EVENT_UP);
  1875. }
  1878. /*****************************************************************************
  1879.  * FUNCTION
  1880.  *  HandwritingSettingInlineColor
  1881.  * DESCRIPTION
  1882.  *  This function updates softkey and iInlinePen color according to change in Pen Color
  1883.  * PARAMETERS
  1884.  *  index       [IN]        
  1885.  *  a(?)        [IN]        
  1886.  *  b(?)        [OUT]       
  1887.  * RETURNS
  1888.  *  void
  1889.  *****************************************************************************/
  1890. void HandwritingSettingInlineColor(U16 index)
  1891. {
  1892.     /*----------------------------------------------------------------*/
  1893.     /* Local Variables                                                */
  1894.     /*----------------------------------------------------------------*/
  1896.     /*----------------------------------------------------------------*/
  1897.     /* Code Body                                                      */
  1898.     /*----------------------------------------------------------------*/
  1899.     if (index < MAX_PEN_COLORS)
  1900.     {
  1901.         if (index != gInlinePenColorIndex)
  1902.         {
  1903.             set_wgui_inline_list_menu_changed();
  1904.         }
  1905.         gInlinePenColorIndex = index;
  1906.     }
  1907. }
  1910. /*****************************************************************************
  1911.  * FUNCTION
  1912.  *  EntryHandWritingSettingScr
  1913.  * DESCRIPTION
  1914.  *  Entry function for Pen Setting Screen
  1915.  * PARAMETERS
  1916.  *  void
  1917.  *  a(?)        [IN]        
  1918.  *  b(?)        [OUT]       
  1919.  * RETURNS
  1920.  *  void
  1921.  *****************************************************************************/
  1922. void EntryHandWritingSettingScr(void)
  1923. {
  1924.     /*----------------------------------------------------------------*/
  1925.     /* Local Variables                                                */
  1926.     /*----------------------------------------------------------------*/
  1927.     U8 *guiBuffer;
  1928.     U8 *inputBuffer;
  1929.     U16 inputBufferSize;
  1930.     U16 list_of_icons[4];
  1932.     S32 iCount;
  1933.     S16 item_offset = 0;
  1935.     /*----------------------------------------------------------------*/
  1936.     /* Code Body                                                      */
  1937.     /*----------------------------------------------------------------*/
  1938.     EntryNewScreen(SCR_HANDWRITING_SETTING, ExitHandWritingSettingScr, NULL, NULL);
  1939.     guiBuffer = GetCurrGuiBuffer(SCR_HANDWRITING_SETTING);
  1940.     inputBuffer = GetCurrNInputBuffer(SCR_HANDWRITING_SETTING, &inputBufferSize);
  1942.     for (iCount = 0; iCount < MAX_PEN_SPEED; ++iCount)
  1943.     {
  1944.         g_pen_speed_str_list[iCount] = (U8*) GetString((U16) (iCount + STR_HANDWRITING_FAST));
  1945.     }
  1947.     gInlinePenSpeed = g_phnset_cntx_p->pen_speed;
  1948.     gInlinePenColorIndex = g_phnset_cntx_p->pen_color;
  1950.     /* start of Category 57 */
  1951.     InitializeCategory57Screen();
  1953.     /* Pen speed */
  1954.     SetInlineItemCaption(&wgui_inline_items[item_offset++], (PU8) GetString(STR_HANDWRITING_PEN_SPEED));
  1956.     SetInlineItemActivation(&wgui_inline_items[item_offset], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  1957.     SetInlineItemSelect(&wgui_inline_items[item_offset++], MAX_PEN_SPEED, g_pen_speed_str_list, &gInlinePenSpeed);
  1959.     /* Pen Color */
  1960.     SetInlineItemCaption(&wgui_inline_items[item_offset++], (PU8) GetString(STR_HANDWRITING_PEN_COLOR));
  1962.     SetInlineItemActivation(&wgui_inline_items[item_offset], INLINE_ITEM_ACTIVATE_WITHOUT_KEY_EVENT, 0);
  1963.     SetInlineItemColorSelect(
  1964.         &wgui_inline_items[item_offset++],
  1965.         MAX_PEN_COLORS,
  1966.         (U16) gInlinePenColorIndex,
  1967.         (color*) g_pen_color_list,
  1968.         HandwritingSettingInlineColor);
  1970.     if (inputBuffer != NULL)
  1971.     {
  1972.         SetCategory57Data(wgui_inline_items, item_offset, inputBuffer);
  1973.     }
  1975.     list_of_icons[0] = IMG_GLOBAL_L1;
  1976.     list_of_icons[1] = 0;
  1977.     list_of_icons[2] = IMG_GLOBAL_L2;
  1978.     list_of_icons[3] = 0;
  1980.     ShowCategory57Screen(
  1981.         STR_HANDWRITING_SETTING,
  1982.         GetRootTitleIcon(MENU_SETTING_HANDWRITING),
  1983.         STR_GLOBAL_OK,
  1984.         IMG_GLOBAL_OK,
  1985.         STR_GLOBAL_BACK,
  1986.         IMG_GLOBAL_BACK,
  1987.         item_offset,
  1988.         list_of_icons,
  1989.         wgui_inline_items,
  1990.         0,
  1991.         guiBuffer);
  1993.     SetCategory57RightSoftkeyFunctions(EntryScrHandwritingSettingConfirm, GoBackHistory);
  1994. }
  1997. /*****************************************************************************
  1998.  * FUNCTION
  1999.  *  ExitHandWritingSettingScr
  2000.  * DESCRIPTION
  2001.  *  Exit function for Pen Setting Screen
  2002.  * PARAMETERS
  2003.  *  void
  2004.  *  a(?)        [IN]        
  2005.  *  b(?)        [OUT]       
  2006.  * RETURNS
  2007.  *  void
  2008.  *****************************************************************************/
  2009. void ExitHandWritingSettingScr(void)
  2010. {
  2011.     /*----------------------------------------------------------------*/
  2012.     /* Local Variables                                                */
  2013.     /*----------------------------------------------------------------*/
  2014.     history h;
  2015.     U16 inputBufferSize;
  2017.     /*----------------------------------------------------------------*/
  2018.     /* Code Body                                                      */
  2019.     /*----------------------------------------------------------------*/
  2020.     CloseCategory57Screen();
  2021.     h.scrnID = SCR_HANDWRITING_SETTING;
  2022.     h.entryFuncPtr = EntryHandWritingSettingScr;
  2023.     GetCategoryHistory(h.guiBuffer);
  2024.     inputBufferSize = (U16) GetCategory57DataSize();
  2025.     GetCategory57Data((U8*) h.inputBuffer);
  2026.     AddNHistory(h, inputBufferSize);
  2027. }
  2030. /*****************************************************************************
  2031.  * FUNCTION
  2032.  *  WriteNvramCalibrationData
  2033.  * DESCRIPTION
  2034.  *  Writes calibration setting in NVRAM
  2035.  * PARAMETERS
  2036.  *  calibration_data        [IN]        
  2037.  * RETURNS
  2038.  *  void
  2039.  * REMARKS
  2040.  *  This function assumes that NVRAM Values of Calibration data are stored in
  2041.  *  a fixed order in NVRAMEnum.h file . Order should not be changed.
  2042.  *  
  2043.  *  It is not atomic operation between ReadRecord and WriteRecord, but it's okay.
  2044.  *****************************************************************************/
  2045. static void WriteNvramCalibrationData(mmi_pen_calibration_struct *calibration_data)
  2046. {
  2047.     /*----------------------------------------------------------------*/
  2048.     /* Local Variables                                                */
  2049.     /*----------------------------------------------------------------*/
  2050.     U8 tempBuffer[NVRAM_CACHE_SIZE];
  2051.     S16 pError = 0;
  2053.     /*----------------------------------------------------------------*/
  2054.     /* Code Body                                                      */
  2055.     /*----------------------------------------------------------------*/
  2056.     /* Note: It is not atomic operation between ReadRecord and WriteRecord. */
  2057.     if (ReadRecord(NVRAM_EF_CACHE_DOUBLE_LID, 1, tempBuffer, NVRAM_CACHE_SIZE, &pError) < 0)
  2058.     {
  2059.         PRINT_INFORMATION(("Calibration NVRAM data read failed , Error = %d", (int)pError));
  2060.         /* Do some error handling */
  2061.     }
  2062.     else
  2063.     {
  2064.         S16 i, j;
  2066.         for (i = NVRAM_PEN_CALIBRATION_VALUE1, j = 0; i <= NVRAM_PEN_CALIBRATION_VALUE1 + PEN_CALIBRATION_DATA_SIZE - 1;
  2067.              i++, j++)
  2068.         {
  2069.             memcpy(&tempBuffer[i * DS_DOUBLE], &calibration_data->data[j], DS_DOUBLE);
  2070.         }
  2071.         WriteRecord(NVRAM_EF_CACHE_DOUBLE_LID, 1, tempBuffer, NVRAM_CACHE_SIZE, &pError);
  2072.     }
  2074.     g_phnset_cntx_p->is_default_calibration_set = MMI_TRUE;
  2075. }
  2078. /*****************************************************************************
  2079.  * FUNCTION
  2080.  *  WriteNvramFactoryDefaultCalibrationData
  2081.  * DESCRIPTION
  2082.  *  Writes factory default calibration setting in NVRAM
  2083.  * PARAMETERS
  2084.  *  calibration_data        [IN]        
  2085.  * RETURNS
  2086.  *  void
  2087.  * REMARKS
  2088.  *  This function assumes that NVRAM Values of Calibration data are stored in
  2089.  *  a fixed order in NVRAMEnum.h file . Order should not be changed.
  2090.  *  
  2091.  *  It is not atomic operation between ReadRecord and WriteRecord, but it's okay.
  2092.  *****************************************************************************/
  2093. static void WriteNvramFactoryDefaultCalibrationData(mmi_pen_calibration_struct *calibration_data)
  2094. {
  2095.     /*----------------------------------------------------------------*/
  2096.     /* Local Variables                                                */
  2097.     /*----------------------------------------------------------------*/
  2098.     U8 tempBuffer[NVRAM_CACHE_SIZE];
  2099.     S16 pError = 0;
  2101.     /*----------------------------------------------------------------*/
  2102.     /* Code Body                                                      */
  2103.     /*----------------------------------------------------------------*/
  2104.     /* Note: It is not atomic operation between ReadRecord and WriteRecord. */
  2105.     if (ReadRecord(NVRAM_EF_CACHE_DOUBLE_LID, 1, tempBuffer, NVRAM_CACHE_SIZE, &pError) < 0)
  2106.     {
  2107.         PRINT_INFORMATION(("Calibration NVRAM data read failed , Error = %d", (int)pError));
  2108.         /* Do some error handling */
  2109.     }
  2110.     else
  2111.     {
  2112.         S16 i, j;
  2114.         for (i = NVRAM_RESTORE_DEFAULT_PEN_CALIBRATION_VALUE1, j = 0;
  2115.              i <= NVRAM_RESTORE_DEFAULT_PEN_CALIBRATION_VALUE1 + PEN_CALIBRATION_DATA_SIZE - 1; i++, j++)
  2116.         {
  2117.             memcpy(&tempBuffer[i * DS_DOUBLE], &calibration_data->data[j], DS_DOUBLE);
  2118.         }
  2119.         WriteRecord(NVRAM_EF_CACHE_DOUBLE_LID, 1, tempBuffer, NVRAM_CACHE_SIZE, &pError);
  2120.     }
  2122.     g_phnset_cntx_p->is_default_calibration_set = MMI_TRUE;
  2123. }
  2126. /*****************************************************************************
  2127.  * FUNCTION
  2128.  *  ValidateNvramCalibrationData
  2129.  * DESCRIPTION
  2130.  *  Function to validate calibration data read from NVRAM
  2131.  * PARAMETERS
  2132.  *  buffer          [?]         
  2133.  *  start_index     [IN]        
  2134.  *  end_index       [IN]        
  2135.  *  a(?)            [IN]        U8* , S16, S16
  2136.  *  b(?)            [OUT]       BOOL
  2137.  * RETURNS
  2138.  *  void
  2139.  *****************************************************************************/
  2140. static BOOL ValidateNvramCalibrationData(U8 *buffer, S16 start_index, S16 end_index)
  2141. {
  2142.     /*----------------------------------------------------------------*/
  2143.     /* Local Variables                                                */
  2144.     /*----------------------------------------------------------------*/
  2145.     S32 i;
  2146.     unsigned char default_value[] = "xFFxFFxFFxFFxFFxFFxFFxFF";
  2148.     /*----------------------------------------------------------------*/
  2149.     /* Code Body                                                      */
  2150.     /*----------------------------------------------------------------*/
  2151.     for (i = start_index; i <= end_index; i++)
  2152.     {
  2153.         if (memcmp(&buffer[i * DS_DOUBLE], default_value, DS_DOUBLE))
  2154.         {
  2155.             return MMI_TRUE;
  2156.         }
  2157.     }
  2159.     return MMI_FALSE;
  2160. }
  2163. /*****************************************************************************
  2164.  * FUNCTION
  2165.  *  PhnsetReadNvramCalibrationData
  2166.  * DESCRIPTION
  2167.  *  Function to read calibration data from NVRAM
  2168.  * PARAMETERS
  2169.  *  void
  2170.  * RETURNS
  2171.  *  void
  2172.  *****************************************************************************/
  2173. void PhnsetReadNvramCalibrationData(void)
  2174. {
  2175.     /*----------------------------------------------------------------*/
  2176.     /* Local Variables                                                */
  2177.     /*----------------------------------------------------------------*/
  2178.     U8 tempBuffer[NVRAM_CACHE_SIZE];
  2179.     S16 pError = 0;
  2181.     /*----------------------------------------------------------------*/
  2182.     /* Code Body                                                      */
  2183.     /*----------------------------------------------------------------*/
  2184.     g_phnset_cntx_p->is_default_calibration_set = MMI_FALSE;
  2186.     if (ReadRecord(NVRAM_EF_CACHE_DOUBLE_LID, 1, tempBuffer, NVRAM_CACHE_SIZE, &pError) < 0)
  2187.     {
  2188.         PRINT_INFORMATION(("Calibration NVRAM data read failed , Error = %d", (int)pError));
  2189.         /* Do nothing, driver will take care */
  2190.         return;
  2191.     }
  2192.     else
  2193.     {
  2194.         S16 i, j;
  2195.         mmi_pen_calibration_struct calibration_data;
  2197.         if (ValidateNvramCalibrationData
  2198.             (tempBuffer, NVRAM_PEN_CALIBRATION_VALUE1, NVRAM_PEN_CALIBRATION_VALUE1 + PEN_CALIBRATION_DATA_SIZE - 1))
  2199.         {
  2200.             /* Use user-calibrated data */
  2201.             for (i = NVRAM_PEN_CALIBRATION_VALUE1, j = 0;
  2202.                  i <= NVRAM_PEN_CALIBRATION_VALUE1 + PEN_CALIBRATION_DATA_SIZE - 1; i++, j++)
  2203.             {
  2204.                 memcpy(&calibration_data.data[j], &tempBuffer[i * DS_DOUBLE], DS_DOUBLE);
  2205.             }
  2206.             mmi_pen_set_calibration_data(&calibration_data);
  2207.             g_phnset_cntx_p->is_default_calibration_set = MMI_TRUE;
  2208.             return;
  2209.         }
  2210.         else
  2211.         {
  2212.             /* Use factory default data */
  2213.             if (ValidateNvramCalibrationData
  2214.                 (tempBuffer, NVRAM_RESTORE_DEFAULT_PEN_CALIBRATION_VALUE1,
  2215.                  NVRAM_RESTORE_DEFAULT_PEN_CALIBRATION_VALUE1 + PEN_CALIBRATION_DATA_SIZE - 1))
  2216.             {
  2217.                 for (i = NVRAM_RESTORE_DEFAULT_PEN_CALIBRATION_VALUE1, j = 0;
  2218.                      i <= NVRAM_RESTORE_DEFAULT_PEN_CALIBRATION_VALUE1 + PEN_CALIBRATION_DATA_SIZE - 1; i++, j++)
  2219.                 {
  2220.                     memcpy(&calibration_data.data[j], &tempBuffer[i * DS_DOUBLE], DS_DOUBLE);
  2221.                 }
  2222.                 mmi_pen_set_calibration_data(&calibration_data);
  2223.                 g_phnset_cntx_p->is_default_calibration_set = MMI_TRUE;
  2224.                 return;
  2225.             }
  2226.         }
  2227.         PRINT_INFORMATION(("NVRAM Calibration Data not found"));
  2228.         /* Do nothing, driver will take care */
  2229.     }
  2230. }
  2232. #if 0
  2233. /* under construction !*/
  2234. /* under construction !*/
  2235. /* under construction !*/
  2236. /* under construction !*/
  2237. /* under construction !*/
  2238. /* under construction !*/
  2239. /* under construction !*/
  2240. /* under construction !*/
  2241. /* under construction !*/
  2242. /* under construction !*/
  2243. /* under construction !*/
  2244. /* under construction !*/
  2245. /* under construction !*/
  2246. /* under construction !*/
  2247. /* under construction !*/
  2248. /* under construction !*/
  2249. /* under construction !*/
  2250. /* under construction !*/
  2251. /* under construction !*/
  2252. /* under construction !*/
  2253. /* under construction !*/
  2254. /* under construction !*/
  2255. /* under construction !*/
  2256. /* under construction !*/
  2257. /* under construction !*/
  2258. /* under construction !*/
  2259. /* under construction !*/
  2260. #endif /* 0 */ 
  2263. /*****************************************************************************
  2264.  * FUNCTION
  2265.  *  CalibrationSettingRestoreData
  2266.  * DESCRIPTION
  2267.  *  Restores calibration setting if user is not able to set calibration data properly
  2268.  * PARAMETERS
  2269.  *  void
  2270.  * RETURNS
  2271.  *  void
  2272.  *****************************************************************************/
  2273. static void CalibrationSettingRestoreData(void)
  2274. {
  2275.     /*----------------------------------------------------------------*/
  2276.     /* Local Variables                                                */
  2277.     /*----------------------------------------------------------------*/
  2279.     /*----------------------------------------------------------------*/
  2280.     /* Code Body                                                      */
  2281.     /*----------------------------------------------------------------*/
  2282.     mmi_pen_set_calibration_data(&g_phnset_calibration_cntx_p->backup_data);
  2283. }
  2286. /*****************************************************************************
  2287.  * FUNCTION
  2288.  *  CalibrationSettingPenDown
  2289.  * DESCRIPTION
  2290.  *  PenDown Handler for Calibration Setting Screen
  2291.  * PARAMETERS
  2292.  *  point       [IN]        
  2293.  * RETURNS
  2294.  *  void
  2295.  *****************************************************************************/
  2296. static void CalibrationSettingPenDown(mmi_pen_point_struct point)
  2297. {
  2298.     /*----------------------------------------------------------------*/
  2299.     /* Local Variables                                                */
  2300.     /*----------------------------------------------------------------*/
  2302.     /*----------------------------------------------------------------*/
  2303.     /* Code Body                                                      */
  2304.     /*----------------------------------------------------------------*/
  2305.     switch (g_phnset_calibration_screen_state)
  2306.     {
  2307.         case CALIBRATION_WELCOME_STATE:
  2308.             g_phnset_calibration_screen_state = CALIBRATION_TOP_LEFT_POINT_STATE;
  2309.             UpdateCalibrationScreen(
  2310.                 IMG_CALIBRATION_TOP_LEFT,
  2311.                 g_phnset_calibration_cntx_p->points[0].x,
  2312.                 g_phnset_calibration_cntx_p->points[0].y,
  2313.                 STR_CALIBRATION_TOP_LEFT_TEXT,
  2314.                 CALIBRATION_TOP_LEFT_POINT_STATE,
  2315.                 MMI_TRUE);
  2317.             mmi_pen_start_calibration(NUM_CALIBRATION_POINTS, g_phnset_calibration_cntx_p->points);
  2318.             break;
  2320.         case CALIBRATION_TOP_LEFT_POINT_STATE:
  2321.             g_phnset_calibration_screen_state = CALIBRATION_BOTTOM_RIGHT_POINT_STATE;
  2322.             UpdateCalibrationScreen(
  2323.                 IMG_CALIBRAION_BOTTOM_RIGHT,
  2324.                 g_phnset_calibration_cntx_p->points[1].x,
  2325.                 g_phnset_calibration_cntx_p->points[1].y,
  2326.                 STR_CALIBRATION_BOTTOM_RIGHT_TEXT,
  2327.                 CALIBRATION_BOTTOM_RIGHT_POINT_STATE,
  2328.                 MMI_TRUE);
  2329.             break;
  2331.         case CALIBRATION_BOTTOM_RIGHT_POINT_STATE:
  2332.             g_phnset_calibration_screen_state = CALIBRATION_CENTER_POINT_STATE;
  2333.             UpdateCalibrationScreen(
  2334.                 IMG_CALIBRATION_CENTER,
  2335.                 g_phnset_calibration_cntx_p->points[2].x,
  2336.                 g_phnset_calibration_cntx_p->points[2].y,
  2337.                 STR_CALIBRATION_CENTER_TEXT,
  2338.                 CALIBRATION_CENTER_POINT_STATE,
  2339.                 MMI_TRUE);
  2340.             break;
  2342.         case CALIBRATION_CENTER_POINT_STATE:
  2343.     #ifndef __MTK_TARGET__  /* Emulate driver's response */
  2344.         {
  2345.             mmi_pen_calibration_struct calibration_data;
  2347.             g_phnset_calibration_cntx_p->finished = MMI_TRUE;
  2349.             /* Write calibration data in NVRAM */
  2350.             mmi_pen_read_calibration_data(&calibration_data);
  2351.             if (g_phnset_calibration_cntx_p->save_to_factory_default)
  2352.             {
  2353.                 WriteNvramFactoryDefaultCalibrationData(&calibration_data);
  2354.             }
  2355.             else
  2356.             {
  2357.                 WriteNvramCalibrationData(&calibration_data);
  2358.             }
  2360.             if (g_phnset_calibration_cntx_p->finish_callback)
  2361.             {
  2362.                 DisplayPopupCallBack(
  2363.                     (U8*) GetString(STR_GLOBAL_DONE),
  2364.                     IMG_GLOBAL_ACTIVATED,
  2365.                     MMI_FALSE,
  2366.                     UI_POPUP_NOTIFYDURATION_TIME,
  2367.                     (U8) SUCCESS_TONE,
  2368.                     g_phnset_calibration_cntx_p->finish_callback);
  2369.             }
  2370.             else
  2371.             {
  2372.                 DisplayPopup(
  2373.                     (U8*) GetString(STR_GLOBAL_DONE),
  2374.                     IMG_GLOBAL_ACTIVATED,
  2375.                     MMI_FALSE,
  2376.                     UI_POPUP_NOTIFYDURATION_TIME,
  2377.                     (U8) SUCCESS_TONE);
  2378.             }
  2379.         }
  2380.     #endif /* __MTK_TARGET__ */ 
  2381.             break;
  2383.         default:
  2384.             MMI_ASSERT(0);
  2385.             break;
  2386.     }
  2387. }
  2390. /*****************************************************************************
  2391.  * FUNCTION
  2392.  *  PhnsetCalibrationDriverRsp
  2393.  * DESCRIPTION
  2394.  *  Protocol event handler of driver response
  2395.  * PARAMETERS
  2396.  *  msg     [IN]        Local parameter
  2397.  * RETURNS
  2398.  *  void
  2399.  *****************************************************************************/
  2400. #ifdef __MTK_TARGET__
  2401. void PhnsetCalibrationDriverRsp(void *msg)
  2402. {
  2403.     /*----------------------------------------------------------------*/
  2404.     /* Local Variables                                                */
  2405.     /*----------------------------------------------------------------*/
  2406.     tp_cali_done_struct *rsp;
  2408.     /*----------------------------------------------------------------*/
  2409.     /* Code Body                                                      */
  2410.     /*----------------------------------------------------------------*/
  2411.     rsp = (tp_cali_done_struct*) msg;
  2413.     if (GetExitScrnID() != SCR_CALIBRATION_SETTING)
  2414.     {
  2415.         /* Race condition that screen is changed. */
  2416.         return;
  2417.     }
  2419.     if (rsp->result)
  2420.     {
  2421.         mmi_pen_calibration_struct calibration_data;
  2423.         g_phnset_calibration_cntx_p->finished = MMI_TRUE;
  2425.         /* Write calibration data in NVRAM */
  2426.         mmi_pen_read_calibration_data(&calibration_data);
  2427.         if (g_phnset_calibration_cntx_p->save_to_factory_default)
  2428.         {
  2429.             WriteNvramFactoryDefaultCalibrationData(&calibration_data);
  2430.         }
  2431.         else
  2432.         {
  2433.             WriteNvramCalibrationData(&calibration_data);
  2434.         }
  2436.         if (g_phnset_calibration_cntx_p->finish_callback)
  2437.         {
  2438.             DisplayPopupCallBack(
  2439.                 (U8*) GetString(STR_GLOBAL_DONE),
  2440.                 IMG_GLOBAL_ACTIVATED,
  2441.                 MMI_FALSE,
  2442.                 UI_POPUP_NOTIFYDURATION_TIME,
  2443.                 (U8) SUCCESS_TONE,
  2444.                 g_phnset_calibration_cntx_p->finish_callback);
  2445.         }
  2446.         else
  2447.         {
  2448.             DisplayPopup(
  2449.                 (U8*) GetString(STR_GLOBAL_DONE),
  2450.                 IMG_GLOBAL_ACTIVATED,
  2451.                 MMI_FALSE,
  2452.                 UI_POPUP_NOTIFYDURATION_TIME,
  2453.                 (U8) SUCCESS_TONE);
  2454.         }
  2455.     }
  2456.     else
  2457.     {
  2458.         /*
  2459.          * Flush pen event queue because Pen Down event of the 3rd point might come after 
  2460.          * * MSG_ID_TP_CALI_DONE, but it is changed to CALIBRATION_TOP_LEFT_POINT_STATE.
  2461.          */
  2462.         mmi_pen_reset();
  2464.         /* Restart calibration process */
  2465.         CalibrationSettingRestoreData();
  2467.         g_phnset_calibration_screen_state = CALIBRATION_TOP_LEFT_POINT_STATE;
  2468.         UpdateCalibrationScreen(
  2469.             IMG_CALIBRATION_TOP_LEFT,
  2470.             g_phnset_calibration_cntx_p->points[0].x,
  2471.             g_phnset_calibration_cntx_p->points[0].y,
  2472.             STR_CALIBRATION_TOP_LEFT_TEXT,
  2473.             CALIBRATION_TOP_LEFT_POINT_STATE,
  2474.             MMI_TRUE);
  2476.         mmi_pen_start_calibration(NUM_CALIBRATION_POINTS, g_phnset_calibration_cntx_p->points);
  2477.     }
  2478. }
  2479. #endif /* __MTK_TARGET__ */ 
  2482. /*****************************************************************************
  2483.  * FUNCTION
  2484.  *  EntryCalibrationSettingScr
  2485.  * DESCRIPTION
  2486.  *  Entry function for Calibration Setting Screen
  2487.  * PARAMETERS
  2488.  *  void
  2489.  * RETURNS
  2490.  *  void
  2491.  *****************************************************************************/
  2492. void EntryCalibrationSettingScr(void)
  2493. {
  2494.     /*----------------------------------------------------------------*/
  2495.     /* Local Variables                                                */
  2496.     /*----------------------------------------------------------------*/
  2498.     /*----------------------------------------------------------------*/
  2499.     /* Code Body                                                      */
  2500.     /*----------------------------------------------------------------*/
  2501. #ifdef __MTK_TARGET__
  2502.     SetProtocolEventHandler(PhnsetCalibrationDriverRsp, MSG_ID_TP_CALI_DONE);
  2503. #endif 
  2505.     EntryNewScreen(SCR_CALIBRATION_SETTING, ExitCalibrationSettingScr, NULL, NULL);
  2507.     g_phnset_calibration_cntx_p = OslMalloc(sizeof(mmi_phnset_calibration_struct));
  2509.     g_phnset_calibration_cntx_p->finished = MMI_FALSE;
  2511.     g_phnset_calibration_cntx_p->save_to_factory_default = MMI_FALSE;
  2513. #ifdef __MMI_TOUCH_SCREEN__
  2514.     g_phnset_calibration_cntx_p->finish_callback = NULL;
  2516.     /* 1st & 2nd point should not on the margin */
  2517.     g_phnset_calibration_cntx_p->points[0].x = UI_device_width / 10;
  2518.     g_phnset_calibration_cntx_p->points[0].y = UI_device_height / 10;
  2519.     g_phnset_calibration_cntx_p->points[1].x = UI_device_width * 9 / 10;
  2520.     g_phnset_calibration_cntx_p->points[1].y = UI_device_height * 9 / 10;
  2521.     /*
  2522.      * 3rd point should be different from the ceter point 
  2523.      * * such that driver can check it's ADC value
  2524.      */
  2525.     g_phnset_calibration_cntx_p->points[2].x = UI_device_width * 11 / 20;
  2526.     g_phnset_calibration_cntx_p->points[2].y = UI_device_height * 11 / 20;
  2527. #else /* __MMI_TOUCH_SCREEN__ */ 
  2528.     g_phnset_calibration_cntx_p->finish_callback = EntryTestControlAreaScr;
  2530.     /* 1st & 2nd point should not on the margin */
  2531.     g_phnset_calibration_cntx_p->points[0] = tp_calibration_point[0];
  2532.     g_phnset_calibration_cntx_p->points[1] = tp_calibration_point[1];
  2533.     g_phnset_calibration_cntx_p->points[2] = tp_calibration_point[2];
  2535. #endif /* __MMI_TOUCH_SCREEN__ */ 
  2537.     /* 1.Back up user calibration data */
  2538.     mmi_pen_read_calibration_data(&g_phnset_calibration_cntx_p->backup_data);
  2540.     /* 2 Show Calibration Welcome screen */
  2541.     g_phnset_calibration_screen_state = CALIBRATION_WELCOME_STATE;
  2542.     ShowCalibrationScreen(0, 0, 0, STR_CALIBRATION_WELCOME_TEXT, CALIBRATION_WELCOME_STATE);
  2544.     TurnOnBacklight(0);
  2546.     /* 3. Register Pen Handlers 
  2547.        Because hardware can not get correct ADC value on PenUp, we use PenDown for calibration. */
  2548.     ClearInputEventHandler(MMI_DEVICE_ALL);
  2549.     mmi_pen_register_up_handler(mmi_pen_dummy_hdlr);
  2550.     mmi_pen_register_down_handler(CalibrationSettingPenDown);
  2551.     mmi_pen_register_move_handler(mmi_pen_dummy_hdlr);
  2552.     mmi_pen_register_abort_handler(mmi_pen_dummy_hdlr);
  2553.     mmi_pen_register_repeat_handler(mmi_pen_dummy_hdlr);
  2554.     mmi_pen_register_long_tap_handler(mmi_pen_dummy_hdlr);
  2555. }
  2558. /*****************************************************************************
  2559.  * FUNCTION
  2560.  *  EntryPhnseFactoryDefaultCalibrationScr_internal
  2561.  * DESCRIPTION
  2562.  *  Entry function for Calibration Screen of factory default value
  2563.  * PARAMETERS
  2564.  *  void
  2565.  *  callback(?)     [IN]        Callback function after calibration is finished.
  2566.  * RETURNS
  2567.  *  void
  2568.  *****************************************************************************/
  2569. static void (*g_phnset_factory_default_finish_callback) (void);
  2571. static void EntryPhnseFactoryDefaultCalibrationScr_internal(void)
  2572. {
  2573.     /*----------------------------------------------------------------*/
  2574.     /* Local Variables                                                */
  2575.     /*----------------------------------------------------------------*/
  2577.     /*----------------------------------------------------------------*/
  2578.     /* Code Body                                                      */
  2579.     /*----------------------------------------------------------------*/
  2580.     EntryCalibrationSettingScr();
  2581.     ClearKeyHandler(KEY_END, KEY_EVENT_DOWN);
  2582.     g_phnset_calibration_cntx_p->save_to_factory_default = MMI_TRUE;
  2583.     g_phnset_calibration_cntx_p->finish_callback = g_phnset_factory_default_finish_callback;
  2584. }
  2587. /*****************************************************************************
  2588.  * FUNCTION
  2589.  *  EntryPhnseFactoryDefaultCalibrationScr
  2590.  * DESCRIPTION
  2591.  *  
  2592.  * PARAMETERS
  2593.  *  callback        [IN]        
  2594.  * RETURNS
  2595.  *  void
  2596.  *****************************************************************************/
  2597. void EntryPhnseFactoryDefaultCalibrationScr(void (*callback) (void))
  2598. {
  2599.     /*----------------------------------------------------------------*/
  2600.     /* Local Variables                                                */
  2601.     /*----------------------------------------------------------------*/
  2603.     /*----------------------------------------------------------------*/
  2604.     /* Code Body                                                      */
  2605.     /*----------------------------------------------------------------*/
  2606.     g_phnset_factory_default_finish_callback = callback;
  2607.     EntryPhnseFactoryDefaultCalibrationScr_internal();
  2608. }
  2611. /*****************************************************************************
  2612.  * FUNCTION
  2613.  *  ExitCalibrationSettingScr
  2614.  * DESCRIPTION
  2615.  *  Exit function for Calibration Setting Screen
  2616.  * PARAMETERS
  2617.  *  void
  2618.  * RETURNS
  2619.  *  void
  2620.  *****************************************************************************/
  2621. void ExitCalibrationSettingScr(void)
  2622. {
  2623.     /*----------------------------------------------------------------*/
  2624.     /* Local Variables                                                */
  2625.     /*----------------------------------------------------------------*/
  2626.     history h;
  2627.     U16 nHistory = 0;
  2629.     /*----------------------------------------------------------------*/
  2630.     /* Code Body                                                      */
  2631.     /*----------------------------------------------------------------*/
  2632.     if (!g_phnset_calibration_cntx_p->finished)
  2633.     {
  2634.         /* Restore calibration previously set */
  2635.         mmi_pen_set_calibration_data(&g_phnset_calibration_cntx_p->backup_data);
  2637.         /* Calibration screen should be put in history, e.g. "Invalid SIM" popup on boot */
  2638.         h.scrnID = SCR_CALIBRATION_SETTING;
  2639.         if (g_phnset_calibration_cntx_p->save_to_factory_default)
  2640.         {
  2641.             h.entryFuncPtr = EntryPhnseFactoryDefaultCalibrationScr_internal;
  2642.         }
  2643.         else
  2644.         {
  2645.             h.entryFuncPtr = EntryCalibrationSettingScr;
  2646.         }
  2647.         pfnUnicodeStrcpy((S8*) h.inputBuffer, (S8*) & nHistory);
  2648.         memset(h.guiBuffer, 0, sizeof(h.guiBuffer));
  2649.         AddHistory(h);
  2650.     }
  2652.     g_phnset_calibration_screen_state = CALIBRATION_NULL_STATE;
  2653.     OslMfree(g_phnset_calibration_cntx_p);
  2654.     g_phnset_calibration_cntx_p = NULL;
  2656.     TurnOffBacklight();
  2657. }
  2660. /*****************************************************************************
  2661.  * FUNCTION
  2662.  *  PhnsetNeedFactoryDefaultCalibration
  2663.  * DESCRIPTION
  2664.  *  Whether pen is calibrated.
  2665.  * PARAMETERS
  2666.  *  void
  2667.  * RETURNS
  2668.  * BOOL
  2669.  *****************************************************************************/
  2670. BOOL PhnsetNeedFactoryDefaultCalibration(void)
  2671. {
  2672. #ifdef MMI_ON_WIN32
  2673.     /*----------------------------------------------------------------*/
  2674.     /* Local Variables                                                */
  2675.     /*----------------------------------------------------------------*/
  2677.     /*----------------------------------------------------------------*/
  2678.     /* Code Body                                                      */
  2679.     /*----------------------------------------------------------------*/
  2680.     /* PC Simulator does not support NVRAM */
  2681.     return MMI_FALSE;
  2682. #else /* MMI_ON_WIN32 */ 
  2683.     if (!g_phnset_cntx_p->is_default_calibration_set)
  2684.     {
  2685.         return MMI_TRUE;
  2686.     }
  2687.     else
  2688.     {
  2689.         return MMI_FALSE;
  2690.     }
  2691. #endif /* MMI_ON_WIN32 */ 
  2692. }
  2694. #ifdef __MMI_HANDWRITING_PAD__
  2697. /*****************************************************************************
  2698.  * FUNCTION
  2699.  *  TestControlAreaPenDown
  2700.  * DESCRIPTION
  2701.  *  PenDown Handler for Test Control Area Screen
  2702.  * PARAMETERS
  2703.  *  point       [IN]        
  2704.  * RETURNS
  2705.  *  void
  2706.  *****************************************************************************/
  2707. static void TestControlAreaPenDown(mmi_pen_point_struct point)
  2708. {
  2709.     /*----------------------------------------------------------------*/
  2710.     /* Local Variables                                                */
  2711.     /*----------------------------------------------------------------*/
  2712.     U16 state;
  2714.     /*----------------------------------------------------------------*/
  2715.     /* Code Body                                                      */
  2716.     /*----------------------------------------------------------------*/
  2717.     state = UpdateTestControlAreaScreen(
  2718.                 point,
  2719.                 STR_TEST_CONTROL_AREA_WELCOME_TEXT,
  2720.                 TEST_CONTROL_AREA_TESTING_STATE,
  2721.                 MMI_TRUE);
  2723.     Trace2(TRACE_GROUP_2, "[G] TestControlAreaPenDown - state:%d   (%d, %d) ", state, point.x, point.y);
  2724.     if (state == TEST_CONTROL_AREA_FINISH_STATE)
  2725.     {
  2726.         mmi_frm_setup_default_pen_handler();
  2727.         DisplayPopup(
  2728.             (U8*) GetString(STR_GLOBAL_DONE),
  2729.             IMG_GLOBAL_ACTIVATED,
  2730.             MMI_FALSE,
  2731.             UI_POPUP_NOTIFYDURATION_TIME,
  2732.             (U8) SUCCESS_TONE);
  2733.     }
  2734. }
  2737. /*****************************************************************************
  2738.  * FUNCTION
  2739.  *  ExitControlAreaTestingScr
  2740.  * DESCRIPTION
  2741.  *  Exit function for Calibration Setting Screen
  2742.  * PARAMETERS
  2743.  *  void
  2744.  * RETURNS
  2745.  *  void
  2746.  *****************************************************************************/
  2747. void ExitControlAreaTestingScr(void)
  2748. {
  2749.     /*----------------------------------------------------------------*/
  2750.     /* Local Variables                                                */
  2751.     /*----------------------------------------------------------------*/
  2753.     /*----------------------------------------------------------------*/
  2754.     /* Code Body                                                      */
  2755.     /*----------------------------------------------------------------*/
  2756.     TurnOffBacklight();
  2757. }
  2760. /*****************************************************************************
  2761.  * FUNCTION
  2762.  *  EntryTestControlAreaScr
  2763.  * DESCRIPTION
  2764.  *  Entry function for Test Control Area Screen
  2765.  * PARAMETERS
  2766.  *  void
  2767.  * RETURNS
  2768.  *  void
  2769.  *****************************************************************************/
  2770. void EntryTestControlAreaScr(void)
  2771. {
  2772.     /*----------------------------------------------------------------*/
  2773.     /* Local Variables                                                */
  2774.     /*----------------------------------------------------------------*/
  2775.     mmi_pen_point_struct pos = {0};
  2777.     /*----------------------------------------------------------------*/
  2778.     /* Code Body                                                      */
  2779.     /*----------------------------------------------------------------*/
  2780.     EntryNewScreen(SCR_CALIBRATION_CONTROL_AREA_TESTING, ExitControlAreaTestingScr, NULL, NULL);
  2782.     /* Show control area test screen */
  2783.     ShowTestControlAreaScreen(pos, STR_TEST_CONTROL_AREA_WELCOME_TEXT, TEST_CONTROL_AREA_WELCOME_STATE);
  2785.     TurnOnBacklight(0);
  2787.     /* 2. Register Pen Handlers 
  2788.        Because hardware can not get correct ADC value on PenUp, we use PenDown for calibration. */
  2789.     ClearInputEventHandler(MMI_DEVICE_ALL);
  2790.     mmi_pen_register_up_handler(mmi_pen_dummy_hdlr);
  2791.     mmi_pen_register_down_handler(TestControlAreaPenDown);
  2792.     mmi_pen_register_move_handler(mmi_pen_dummy_hdlr);
  2793.     mmi_pen_register_abort_handler(mmi_pen_dummy_hdlr);
  2794.     mmi_pen_register_repeat_handler(mmi_pen_dummy_hdlr);
  2795.     mmi_pen_register_long_tap_handler(mmi_pen_dummy_hdlr);
  2797. }
  2799. #endif /* __MMI_HANDWRITING_PAD__ */ 
  2802. /*****************************************************************************
  2803.  * FUNCTION
  2804.  *  PhnsetGetHandwritingColor
  2805.  * DESCRIPTION
  2806.  *  Get handwriting stroke color
  2807.  * PARAMETERS
  2808.  *  void
  2809.  * RETURNS
  2810.  *  color
  2811.  *****************************************************************************/
  2812. color PhnsetGetHandwritingColor(void)
  2813. {
  2814.     /*----------------------------------------------------------------*/
  2815.     /* Local Variables                                                */
  2816.     /*----------------------------------------------------------------*/
  2818.     /*----------------------------------------------------------------*/
  2819.     /* Code Body                                                      */
  2820.     /*----------------------------------------------------------------*/
  2821.     MMI_ASSERT(g_phnset_cntx_p->pen_color < MAX_PEN_COLORS);
  2822.     return g_pen_color_list[g_phnset_cntx_p->pen_color];
  2823. }
  2826. /*****************************************************************************
  2827.  * FUNCTION
  2828.  *  PhnsetGetHandwritingSpeed
  2829.  * DESCRIPTION
  2830.  *  Get handwriting speed
  2831.  * PARAMETERS
  2832.  *  void
  2833.  * RETURNS
  2834.  *  PHNSET_HANDWRITING_SPEED_ENUM
  2835.  *****************************************************************************/
  2836. PHNSET_HANDWRITING_SPEED_ENUM PhnsetGetHandwritingSpeed(void)
  2837. {
  2838.     /*----------------------------------------------------------------*/
  2839.     /* Local Variables                                                */
  2840.     /*----------------------------------------------------------------*/
  2842.     /*----------------------------------------------------------------*/
  2843.     /* Code Body                                                      */
  2844.     /*----------------------------------------------------------------*/
  2845.     switch (g_phnset_cntx_p->pen_speed)
  2846.     {
  2847.         case 0:
  2848.             return PHNSET_HANDWRITING_FAST;
  2849.         case 1:
  2850.             return PHNSET_HANDWRITING_MEDIUM;
  2851.         case 2:
  2852.             return PHNSET_HANDWRITING_SLOW;
  2853.         default:
  2854.             MMI_ASSERT(0);
  2855.             return PHNSET_HANDWRITING_MEDIUM;
  2856.     }
  2857. }
  2859. #endif /* defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__) */ 
  2862. /*****************************************************************************
  2863.  * FUNCTION