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

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

MTK

开发平台：

C/C++

CallBarring.c：源码内容
  1. /*****************************************************************************
  2. *  Copyright Statement:
  3. *  --------------------
  4. *  This software is protected by Copyright and the information contained
  5. *  herein is confidential. The software may not be copied and the information
  6. *  contained herein may not be used or disclosed except with the written
  7. *  permission of MediaTek Inc. (C) 2005
  8. *
  9. *  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
  10. *  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
  11. *  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
  12. *  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
  13. *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
  14. *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
  15. *  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
  16. *  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
  17. *  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
  18. *  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
  19. *  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
  20. *  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  21. *
  22. *  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  23. *  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
  24. *  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
  25. *  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
  26. *  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
  27. *
  28. *  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  29. *  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
  30. *  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
  31. *  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
  32. *  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
  33. *
  34. *****************************************************************************/
  36. /*******************************************************************************
  37.  * Filename:
  38.  * ---------
  39.  * CallBarring.c
  40.  *
  41.  * Project:
  42.  * --------
  43.  *   MAUI
  44.  *
  45.  * Description:
  46.  * ------------
  47.  *   <file description>.
  48.  *
  49.  * Author:
  50.  * -------
  51.  * -------
  52.  *
  53.  *==============================================================================
  54.  *             HISTORY
  55.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  56.  *------------------------------------------------------------------------------
  57.  * removed!
  58.  *
  59.  * removed!
  60.  * removed!
  61.  * removed!
  62.  *
  63.  * removed!
  64.  * removed!
  65.  * removed!
  66.  *
  67.  * removed!
  68.  * removed!
  69.  * removed!
  70.  *
  71.  *------------------------------------------------------------------------------
  72.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
  73.  *============================================================================== 
  74.  *******************************************************************************/
  76. /**
  77.  * Copyright Notice
  78.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  79.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  80.  *  (It is illegal to remove this copyright notice from this software or any
  81.  *  portion of it)
  82.  */
  83. /**************************************************************
  85.    FILENAME : CallBarring.c
  87.    PURPOSE     : Call Barring Application - call setup
  89.    REMARKS     : nil
  91.    AUTHOR      : Anil Kumar Vutukuru
  93.    DATE     : 11/14/2003
  95. **************************************************************/
  96. #include "stdC.h"
  97. #include "L4Dr1.h"
  98. #include "CSP.h"
  99. #include "MainMenuDef.h"
  100. #include "MMI_features.h"
  101. #include "ProtocolEvents.h"
  102. #include "PhoneBookTypes.h"
  103. #include "CallSetUp.h"
  104. #include "CallBarrng.h"
  105. #include "CallSetUpEnum.h"
  106. #include "CommonScreens.h"
  107. #include "CallmanagementIdDef.h"
  108. #include "CallManagementGProt.h"
  109. #include "MessagesExDcl.h"
  110. #include "wgui_categories.h"
  111. #include "wgui_categories_inputs.h"
  112. #include "SettingDefs.h"
  115. /*****************************************************************************
  116.  * FUNCTION
  117.  *  InitCallBarring
  118.  * DESCRIPTION
  119.  *  Initializes the call barring application
  120.  * NA
  121.  *  
  122.  * PARAMETERS
  123.  *  void
  124.  * RETURNS
  125.  *  void
  126.  *****************************************************************************/
  127. void InitCallBarring(void)
  128. {
  129.     /*----------------------------------------------------------------*/
  130.     /* Local Variables                                                */
  131.     /*----------------------------------------------------------------*/
  133.     /*----------------------------------------------------------------*/
  134.     /* Code Body                                                      */
  135.     /*----------------------------------------------------------------*/
  136.     /* set hilite handlers for the individual menu items */
  137.     SetHiliteHandler(MENU8237_SCR8093_MNGCALL_MENU_BARRING, HighlightCALLSETCallBarring);
  138.     SetHiliteHandler(MENU_CALL_BARRING_OUTGOING, HighlightCALLSETCallBarringOutgoing);
  139.     SetHiliteHandler(MENU_CALL_BARRING_INCOMING, HighlightCALLSETCallBarringIncoming);
  140.     SetHiliteHandler(MENU_CALL_BARRING_CANCELALL, HighlightCALLSETCallBarringCancelAll);
  141.     SetHiliteHandler(MENU_CALL_BARRING_CHANGEPASS, HighlightCALLSETCallBarringChangePwd);
  142.     SetHiliteHandler(MENU_BARRING_OUTGOING_ALLCALLS, HighlightCALLSETCallBarringAllOutCalls);
  143.     SetHiliteHandler(MENU_BARRING_OUTGOING_INTERCALL, HighlightCALLSETCallBarringAllOutInter);
  144.     SetHiliteHandler(MENU_BARRING_OUTGOING_INTEREXCEPTHOME, HighlightCALLSETCallBarringAllOutInterExcHome);
  145.     SetHiliteHandler(MENU_BARRING_INCOMING_ALLCALLS, HighlightCALLSETCallBarringAllInCalls);
  146.     SetHiliteHandler(MENU_BARRING_INCOMING_ROAMING, HighlightCALLSETCallBarringAllInRoaming);
  147.     SetHiliteHandler(MENU_BARRING_ACTIVATE, HighlightCALLSETCallBarringActive);
  148.     SetHiliteHandler(MENU_BARRING_DEACTIVATE, HighlightCALLSETCallBarringDeactive);
  149.     SetHiliteHandler(MENU_BARRING_QUERY, HighlightCALLSETCallBarringQuery);
  150.     return;
  151. }
  154. /*****************************************************************************
  155.  * FUNCTION
  156.  *  HighlightCALLSETCallBarring
  157.  * DESCRIPTION
  158.  *  highlite handler for call barring menu item
  159.  * NA
  160.  *  
  161.  * PARAMETERS
  162.  *  void
  163.  * RETURNS
  164.  *  void
  165.  *****************************************************************************/
  166. void HighlightCALLSETCallBarring(void)
  167. {
  168.     /*----------------------------------------------------------------*/
  169.     /* Local Variables                                                */
  170.     /*----------------------------------------------------------------*/
  172.     /*----------------------------------------------------------------*/
  173.     /* Code Body                                                      */
  174.     /*----------------------------------------------------------------*/
  175.     /* Change left/right soft key icon and label */
  176.     ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  177.     ChangeRightSoftkey(STR_GLOBAL_BACK, IMG_GLOBAL_BACK);
  178.     /* set the left/right soft key functions handlers */
  179.     SetLeftSoftkeyFunction(EntryCALLSETBarringMain, KEY_EVENT_UP);
  180.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  181.     /* set the left/right arrow key function handlers */
  182.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  183.     SetKeyHandler(EntryCALLSETBarringMain, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  184.     return;
  185. }
  188. /*****************************************************************************
  189.  * FUNCTION
  190.  *  HighlightCALLSETCallBarringOutgoing
  191.  * DESCRIPTION
  192.  *  highlite handler for the call barring outgoing menu option
  193.  * NA
  194.  *  
  195.  * PARAMETERS
  196.  *  void
  197.  * RETURNS
  198.  *  void
  199.  *****************************************************************************/
  200. void HighlightCALLSETCallBarringOutgoing(void)
  201. {
  202.     /*----------------------------------------------------------------*/
  203.     /* Local Variables                                                */
  204.     /*----------------------------------------------------------------*/
  206.     /*----------------------------------------------------------------*/
  207.     /* Code Body                                                      */
  208.     /*----------------------------------------------------------------*/
  209.     /* set the left/right soft key functions handlers */
  210.     SetLeftSoftkeyFunction(EntryCALLSETBarringOut, KEY_EVENT_UP);
  211.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  212.     /* set the left/right arrow key function handlers */
  213.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  214.     SetKeyHandler(EntryCALLSETBarringOut, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  216.     return;
  217. }
  220. /*****************************************************************************
  221.  * FUNCTION
  222.  *  HighlightCALLSETCallBarringIncoming
  223.  * DESCRIPTION
  224.  *  highlight handler for call barring in case of incoming.
  225.  * NA
  226.  *  
  227.  * PARAMETERS
  228.  *  void
  229.  * RETURNS
  230.  *  void
  231.  *****************************************************************************/
  232. void HighlightCALLSETCallBarringIncoming(void)
  233. {
  234.     /*----------------------------------------------------------------*/
  235.     /* Local Variables                                                */
  236.     /*----------------------------------------------------------------*/
  238.     /*----------------------------------------------------------------*/
  239.     /* Code Body                                                      */
  240.     /*----------------------------------------------------------------*/
  241.     /* Change right soft key icon and label */
  242.     SetLeftSoftkeyFunction(EntryCALLSETBarringIn, KEY_EVENT_UP);
  243.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  244.     /* set the left/right arrow key function handlers */
  245.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  246.     SetKeyHandler(EntryCALLSETBarringIn, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  247.     return;
  248. }
  251. /*****************************************************************************
  252.  * FUNCTION
  253.  *  HighlightCALLSETCallBarringCancelAll
  254.  * DESCRIPTION
  255.  *  highlight handler for call barring cancel all application
  256.  * NA
  257.  *  
  258.  * PARAMETERS
  259.  *  void
  260.  * RETURNS
  261.  *  void
  262.  *****************************************************************************/
  263. void HighlightCALLSETCallBarringCancelAll(void)
  264. {
  265.     /*----------------------------------------------------------------*/
  266.     /* Local Variables                                                */
  267.     /*----------------------------------------------------------------*/
  269.     /*----------------------------------------------------------------*/
  270.     /* Code Body                                                      */
  271.     /*----------------------------------------------------------------*/
  272.     /* storing the menu item selected */
  273.     g_callset_context.SSBarAction = BARRING_CANCEL_ALL;
  274.     /* set the left/right soft key functions handlers */
  275.     SetLeftSoftkeyFunction(EntryCALLSETBarringPass, KEY_EVENT_UP);
  276.     /* micha0529 */
  277.     SetKeyHandler(EntryCALLSETBarringPass, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  278.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  279.     /* set the left/right arrow key function handlers */
  280.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  281.     return;
  282. }
  285. /*****************************************************************************
  286.  * FUNCTION
  287.  *  HighlightCALLSETCallBarringChangePwd
  288.  * DESCRIPTION
  289.  *  highlight handler for changing call barring passwd
  290.  * NA
  291.  *  
  292.  * PARAMETERS
  293.  *  void
  294.  * RETURNS
  295.  *  void
  296.  *****************************************************************************/
  297. void HighlightCALLSETCallBarringChangePwd(void)
  298. {
  299.     /*----------------------------------------------------------------*/
  300.     /* Local Variables                                                */
  301.     /*----------------------------------------------------------------*/
  303.     /*----------------------------------------------------------------*/
  304.     /* Code Body                                                      */
  305.     /*----------------------------------------------------------------*/
  306.     /* storing the menu item selected */
  307.     g_callset_context.SSBarAction = BARRING_CHANGE_PSW;
  308.     /* set the left/right soft key functions handlers */
  309.     SetLeftSoftkeyFunction(EntryCALLSETBarringOldPass, KEY_EVENT_UP);
  310.     /* micha0529 */
  311.     SetKeyHandler(EntryCALLSETBarringOldPass, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  312.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  314.     return;
  315. }
  318. /*****************************************************************************
  319.  * FUNCTION
  320.  *  HighlightCALLSETCallBarringAllOutCalls
  321.  * DESCRIPTION
  322.  *  highlight handler for call barring all outgoing calls.
  323.  * NA
  324.  *  
  325.  * PARAMETERS
  326.  *  void
  327.  * RETURNS
  328.  *  void
  329.  *****************************************************************************/
  330. void HighlightCALLSETCallBarringAllOutCalls(void)
  331. {
  332.     /*----------------------------------------------------------------*/
  333.     /* Local Variables                                                */
  334.     /*----------------------------------------------------------------*/
  336.     /*----------------------------------------------------------------*/
  337.     /* Code Body                                                      */
  338.     /*----------------------------------------------------------------*/
  339.     /* storing the menu item selected */
  340.     g_callset_context.SSBarType = BARRING_OUTGOING_ALLCALLS;
  341.     /* set the left/right soft key functions handlers */
  342.     SetLeftSoftkeyFunction(EntryCALLSETBarringOption, KEY_EVENT_UP);
  343.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  344.     /* set the left/right arrow key function handlers */
  345.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  346.     SetKeyHandler(EntryCALLSETBarringOption, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  347.     return;
  348. }
  351. /*****************************************************************************
  352.  * FUNCTION
  353.  *  HighlightCALLSETCallBarringAllOutInter
  354.  * DESCRIPTION
  355.  *  high light handler for call barring outgoing international calls.
  356.  * NA
  357.  *  
  358.  * PARAMETERS
  359.  *  void
  360.  * RETURNS
  361.  *  void
  362.  *****************************************************************************/
  363. void HighlightCALLSETCallBarringAllOutInter(void)
  364. {
  365.     /*----------------------------------------------------------------*/
  366.     /* Local Variables                                                */
  367.     /*----------------------------------------------------------------*/
  369.     /*----------------------------------------------------------------*/
  370.     /* Code Body                                                      */
  371.     /*----------------------------------------------------------------*/
  372.     /* storing the menu item selected */
  373.     g_callset_context.SSBarType = BARRING_OUTGOING_INTERCALL;
  374.     /* set the left/right soft key functions handlers */
  375.     SetLeftSoftkeyFunction(EntryCALLSETBarringOption, KEY_EVENT_UP);
  376.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  377.     /* set the left/right arrow key function handlers */
  378.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  379.     SetKeyHandler(EntryCALLSETBarringOption, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  381.     return;
  382. }
  385. /*****************************************************************************
  386.  * FUNCTION
  387.  *  HighlightCALLSETCallBarringAllOutInterExcHome
  388.  * DESCRIPTION
  389.  *  highlight handler for call barring outgoing international
  390.  *  calls except home.
  391.  * NA
  392.  *  
  393.  * PARAMETERS
  394.  *  void
  395.  * RETURNS
  396.  *  void
  397.  *****************************************************************************/
  398. void HighlightCALLSETCallBarringAllOutInterExcHome(void)
  399. {
  400.     /*----------------------------------------------------------------*/
  401.     /* Local Variables                                                */
  402.     /*----------------------------------------------------------------*/
  404.     /*----------------------------------------------------------------*/
  405.     /* Code Body                                                      */
  406.     /*----------------------------------------------------------------*/
  407.     /* storing the menu item selected */
  408.     g_callset_context.SSBarType = BARRING_OUTGOING_INTEREXCEPTHOME;
  409.     /* set the left/right soft key functions handlers */
  410.     SetLeftSoftkeyFunction(EntryCALLSETBarringOption, KEY_EVENT_UP);
  411.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  412.     /* set the left/right arrow key function handlers */
  413.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  414.     SetKeyHandler(EntryCALLSETBarringOption, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  415.     return;
  416. }
  419. /*****************************************************************************
  420.  * FUNCTION
  421.  *  HighlightCALLSETCallBarringAllInCalls
  422.  * DESCRIPTION
  423.  *  highlight handler for call barring all international calls.
  424.  * NA
  425.  *  
  426.  * PARAMETERS
  427.  *  void
  428.  * RETURNS
  429.  *  void
  430.  *****************************************************************************/
  431. void HighlightCALLSETCallBarringAllInCalls(void)
  432. {
  433.     /*----------------------------------------------------------------*/
  434.     /* Local Variables                                                */
  435.     /*----------------------------------------------------------------*/
  437.     /*----------------------------------------------------------------*/
  438.     /* Code Body                                                      */
  439.     /*----------------------------------------------------------------*/
  440.     /* storing the menu item selected */
  441.     g_callset_context.SSBarType = BARRING_INCOMING_ALLCALLS;
  442.     /* set the left/right soft key functions handlers */
  443.     SetLeftSoftkeyFunction(EntryCALLSETBarringOption, KEY_EVENT_UP);
  444.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  445.     /* set the left/right arrow key function handlers */
  446.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  447.     SetKeyHandler(EntryCALLSETBarringOption, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  448.     return;
  449. }
  452. /*****************************************************************************
  453.  * FUNCTION
  454.  *  HighlightCALLSETCallBarringAllInRoaming
  455.  * DESCRIPTION
  456.  *  highlight handler for call barring incoming on roaming calls.
  457.  * NA
  458.  *  
  459.  * PARAMETERS
  460.  *  void
  461.  * RETURNS
  462.  *  void
  463.  *****************************************************************************/
  464. void HighlightCALLSETCallBarringAllInRoaming(void)
  465. {
  466.     /*----------------------------------------------------------------*/
  467.     /* Local Variables                                                */
  468.     /*----------------------------------------------------------------*/
  470.     /*----------------------------------------------------------------*/
  471.     /* Code Body                                                      */
  472.     /*----------------------------------------------------------------*/
  473.     /* storing the menu item selected */
  474.     g_callset_context.SSBarType = BARRING_INCOMING_ROAMING;
  475.     /* set the left/right soft key functions handlers */
  476.     SetLeftSoftkeyFunction(EntryCALLSETBarringOption, KEY_EVENT_UP);
  477.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  478.     /* set the left/right arrow key function handlers */
  479.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  480.     SetKeyHandler(EntryCALLSETBarringOption, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  481.     return;
  482. }
  485. /*****************************************************************************
  486.  * FUNCTION
  487.  *  HighlightCALLSETCallBarringActive
  488.  * DESCRIPTION
  489.  *  hightlight handler for call barring activate
  490.  * NA
  491.  *  
  492.  * PARAMETERS
  493.  *  void
  494.  * RETURNS
  495.  *  void
  496.  *****************************************************************************/
  497. void HighlightCALLSETCallBarringActive(void)
  498. {
  499.     /*----------------------------------------------------------------*/
  500.     /* Local Variables                                                */
  501.     /*----------------------------------------------------------------*/
  503.     /*----------------------------------------------------------------*/
  504.     /* Code Body                                                      */
  505.     /*----------------------------------------------------------------*/
  506.     /* storing the menu item selected */
  507.     g_callset_context.SSBarAction = BARRING_ON;
  508.     /* set the left/right soft key functions handlers */
  509.     SetLeftSoftkeyFunction(EntryCALLSETBarringPass, KEY_EVENT_UP);
  510.     /* micha0529 */
  511.     SetKeyHandler(EntryCALLSETBarringPass, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  512.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  513.     return;
  514. }
  517. /*****************************************************************************
  518.  * FUNCTION
  519.  *  HighlightCALLSETCallBarringDeactive
  520.  * DESCRIPTION
  521.  *  hightlight handler for call barring deactivate
  522.  * NA
  523.  *  
  524.  * PARAMETERS
  525.  *  void
  526.  * RETURNS
  527.  *  void
  528.  *****************************************************************************/
  529. void HighlightCALLSETCallBarringDeactive(void)
  530. {
  531.     /*----------------------------------------------------------------*/
  532.     /* Local Variables                                                */
  533.     /*----------------------------------------------------------------*/
  535.     /*----------------------------------------------------------------*/
  536.     /* Code Body                                                      */
  537.     /*----------------------------------------------------------------*/
  538.     /* storing the menu item selected */
  539.     g_callset_context.SSBarAction = BARRING_OFF;
  540.     /* set the left/right soft key functions handlers */
  541.     SetLeftSoftkeyFunction(EntryCALLSETBarringPass, KEY_EVENT_UP);
  542.     /* micha0529 */
  543.     SetKeyHandler(EntryCALLSETBarringPass, KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  544.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  545.     return;
  546. }
  549. /*****************************************************************************
  550.  * FUNCTION
  551.  *  HighlightCALLSETCallBarringQuery
  552.  * DESCRIPTION
  553.  *  hightlight handler for call barring query status
  554.  * NA
  555.  *  
  556.  * PARAMETERS
  557.  *  void
  558.  * RETURNS
  559.  *  void
  560.  *****************************************************************************/
  561. void HighlightCALLSETCallBarringQuery(void)
  562. {
  563.     /*----------------------------------------------------------------*/
  564.     /* Local Variables                                                */
  565.     /*----------------------------------------------------------------*/
  567.     /*----------------------------------------------------------------*/
  568.     /* Code Body                                                      */
  569.     /*----------------------------------------------------------------*/
  570.     /* set the left/right soft key functions handlers */
  571.     SetLeftSoftkeyFunction(SendBarrQuery, KEY_EVENT_UP);
  572.     /* micha0529 */
  573.     ClearKeyHandler(KEY_RIGHT_ARROW, KEY_EVENT_DOWN);
  574.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  575.     return;
  576. }
  579. /*****************************************************************************
  580.  * FUNCTION
  581.  *  EntryCALLSETBarringMain
  582.  * DESCRIPTION
  583.  *  entry function for call barring main menu
  584.  * NA
  585.  *  
  586.  * PARAMETERS
  587.  *  void
  588.  * RETURNS
  589.  *  void
  590.  *****************************************************************************/
  591. void EntryCALLSETBarringMain(void)
  592. {
  593.     /*----------------------------------------------------------------*/
  594.     /* Local Variables                                                */
  595.     /*----------------------------------------------------------------*/
  596.     //micha1229
  597.     //      U16 nDispAttribute; /* Stores display attribue */
  598.     U8 *guiBuffer;              /* Buffer holding history data */
  599.     U16 nNumofItem;
  600.     U16 nStrItemList[MAX_SUB_MENUS];
  602.     /*----------------------------------------------------------------*/
  603.     /* Code Body                                                      */
  604.     /*----------------------------------------------------------------*/
  605.     /* U32 maskingByte=0xFF;
  606.        U32 menuItemId=0xFFFFFFFF; */
  608.     EntryNewScreen(SCR_ID_CALLSET_BARRING_MAIN, NULL, EntryCALLSETBarringMain, NULL);
  610.     /* Get current screen info into gui buffer  for history purposes */
  611.     guiBuffer = GetCurrGuiBuffer(SCR_ID_CALLSET_BARRING_MAIN);
  612.     /* Retrieve no of child of menu item to be displayed */
  613.     nNumofItem = GetNumOfChild_Ext(MENU8237_SCR8093_MNGCALL_MENU_BARRING);      /* diamond, 2005/07/01 add _Ext to menu item functions */
  614.     /* Get attribute of menu to be displayed */
  615.     /* nDispAttribute = GetDispAttributeOfItem(MENU8237_SCR8093_MNGCALL_MENU_BARRING); */
  616.     /* Retrieve string ids in sequence of given menu item to be displayed */
  617.     GetSequenceStringIds_Ext(MENU8237_SCR8093_MNGCALL_MENU_BARRING, nStrItemList);      /* diamond, 2005/07/01 add _Ext to menu item functions */
  618.     /* Set current parent id */
  619.     SetParentHandler(MENU8237_SCR8093_MNGCALL_MENU_BARRING);
  620.     /* Register highlight handler to be called in menu screen */
  621.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  623.     /* diamond, 2005/07/01 removed for new menu item architecture to CPHS */
  624. #if 0
  625. /* under construction !*/
  626. /* under construction !*/
  627. /* under construction !*/
  628. /* under construction !*/
  629. /* under construction !*/
  630. /* under construction !*/
  631. /* under construction !*/
  632. /* under construction !*/
  633. /* under construction !*/
  634. /* under construction !*/
  635. #endif /* 0 */ 
  637.     /* Display Screen */
  638.     ShowCategory15Screen(
  639.         STR_MENU_CALL_BARRING,
  640.         MAIN_MENU_TITLE_SETTINGS_ICON,
  641.         STR_GLOBAL_OK,
  642.         IMG_GLOBAL_OK,
  643.         STR_GLOBAL_BACK,
  644.         IMG_GLOBAL_BACK,
  645.         nNumofItem,
  646.         nStrItemList,
  647.         (U16*) gIndexIconsImageList,
  648.         1,
  649.         0,
  650.         guiBuffer);
  651.     /* Register function with right softkey */
  652.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  653.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  654.     /* Register Exit handler */
  655.     return;
  656. }
  659. /*****************************************************************************
  660.  * FUNCTION
  661.  *  EntryCALLSETBarringOut
  662.  * DESCRIPTION
  663.  *  entry function for out going call barring menu
  664.  * NA
  665.  *  
  666.  * PARAMETERS
  667.  *  void
  668.  * RETURNS
  669.  *  void
  670.  *****************************************************************************/
  671. void EntryCALLSETBarringOut(void)
  672. {
  673.     /*----------------------------------------------------------------*/
  674.     /* Local Variables                                                */
  675.     /*----------------------------------------------------------------*/
  676.     //micha1229
  677.     //      U16 nDispAttribute; /* Stores display attribue */
  678.     U8 *guiBuffer;              /* Buffer holding history data */
  679.     U16 nNumofItem;
  680.     U16 nStrItemList[MAX_SUB_MENUS];
  682.     /*----------------------------------------------------------------*/
  683.     /* Code Body                                                      */
  684.     /*----------------------------------------------------------------*/
  685.     /* U32 maskingByte=0xFFFFFFFF;
  686.        U32 menuItemId=0xFFFFFFFF; */
  688.     EntryNewScreen(SCR_ID_CALLSET_BARRING_OUT, NULL, EntryCALLSETBarringOut, NULL);
  690.     /* Get current screen info into gui buffer  for history purposes */
  691.     guiBuffer = GetCurrGuiBuffer(SCR_ID_CALLSET_BARRING_OUT);
  692.     /* Retrieve no of child of menu item to be displayed */
  693.     nNumofItem = GetNumOfChild_Ext(MENU_CALL_BARRING_OUTGOING); /* diamond, 2005/07/01 add _Ext to menu item functions */
  694.     /* Get attribute of menu to be displayed */
  695.     /* nDispAttribute = GetDispAttributeOfItem(MENU_CALL_BARRING_OUTGOING); */
  696.     /* Retrieve string ids in sequence of given menu item to be displayed */
  697.     GetSequenceStringIds_Ext(MENU_CALL_BARRING_OUTGOING, nStrItemList); /* diamond, 2005/07/01 add _Ext to menu item functions */
  698.     /* Set current parent id */
  699.     SetParentHandler(MENU_CALL_BARRING_OUTGOING);
  700.     /* Register highlight handler to be called in menu screen */
  701.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  703.     /* diamond, 2005/07/01 removed for new menu item architecture to CPHS */
  704. #if 0
  705. /* under construction !*/
  706. /* under construction !*/
  707. /* under construction !*/
  708. /* under construction !*/
  709. /* under construction !*/
  710. /* under construction !*/
  711. /* under construction !*/
  712. /* under construction !*/
  713. /* under construction !*/
  714. /* under construction !*/
  715. #endif /* 0 */ 
  717.     /* Display Category Screen */
  718.     ShowCategory15Screen(
  719.         STR_BARRING_OUTGOING_CALL_CAPTION,
  720.         MAIN_MENU_TITLE_SETTINGS_ICON,
  721.         STR_GLOBAL_OK,
  722.         IMG_GLOBAL_OK,
  723.         STR_GLOBAL_BACK,
  724.         IMG_GLOBAL_BACK,
  725.         nNumofItem,
  726.         nStrItemList,
  727.         (U16*) gIndexIconsImageList,
  728.         1,
  729.         0,
  730.         guiBuffer);
  731.     /* Register function with right softkey */
  732.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  733.     /* Register Exit handler */
  734.     return;
  735. }
  738. /*****************************************************************************
  739.  * FUNCTION
  740.  *  EntryCALLSETBarringIn
  741.  * DESCRIPTION
  742.  *  entry function for incoimg call barring menu
  743.  * NA
  744.  *  
  745.  * PARAMETERS
  746.  *  void
  747.  * RETURNS
  748.  *  void
  749.  *****************************************************************************/
  750. void EntryCALLSETBarringIn(void)
  751. {
  752.     /*----------------------------------------------------------------*/
  753.     /* Local Variables                                                */
  754.     /*----------------------------------------------------------------*/
  755.     //micha1229
  756.     //      U16 nDispAttribute; /* Stores display attribue */
  757.     U8 *guiBuffer;              /* Buffer holding history data */
  758.     U16 nNumofItem;
  759.     U16 nStrItemList[MAX_SUB_MENUS];
  761.     /*----------------------------------------------------------------*/
  762.     /* Code Body                                                      */
  763.     /*----------------------------------------------------------------*/
  764.     /* U32 maskingByte=0xFFFFFFFF;
  765.        U32 menuItemId=0xFFFFFFFF; */
  767.     EntryNewScreen(SCR_ID_CALLSET_BARRING_IN, NULL, EntryCALLSETBarringIn, NULL);
  769.     /* Get current screen info into gui buffer  for history purposes */
  770.     guiBuffer = GetCurrGuiBuffer(SCR_ID_CALLSET_BARRING_IN);
  771.     /* Retrieve no of child of menu item to be displayed */
  772.     nNumofItem = GetNumOfChild_Ext(MENU_CALL_BARRING_INCOMING); /* diamond, 2005/07/01 add _Ext to menu item functions */
  773.     /* Get attribute of menu to be displayed */
  774.     /* nDispAttribute = GetDispAttributeOfItem(MENU8237_SCR8093_MNGCALL_MENU_BARRING); */
  775.     /* Retrieve string ids in sequence of given menu item to be displayed */
  776.     GetSequenceStringIds_Ext(MENU_CALL_BARRING_INCOMING, nStrItemList); /* diamond, 2005/07/01 add _Ext to menu item functions */
  777.     /* Set current parent id */
  778.     SetParentHandler(MENU_CALL_BARRING_INCOMING);
  779.     /* Register highlight handler to be called in menu screen */
  780.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  782.     /* diamond, 2005/07/01 removed for new menu item architecture to CPHS */
  783. #if 0
  784. /* under construction !*/
  785. /* under construction !*/
  786. /* under construction !*/
  787. /* under construction !*/
  788. /* under construction !*/
  789. /* under construction !*/
  790. /* under construction !*/
  791. #endif /* 0 */ 
  793.     /* Display Category Screen */
  794.     ShowCategory15Screen(
  795.         STR_MENU_BARRING_INCOMING_MAIN,
  796.         MAIN_MENU_TITLE_SETTINGS_ICON,
  797.         STR_GLOBAL_OK,
  798.         IMG_GLOBAL_OK,
  799.         STR_GLOBAL_BACK,
  800.         IMG_GLOBAL_BACK,
  801.         nNumofItem,
  802.         nStrItemList,
  803.         (U16*) gIndexIconsImageList,
  804.         1,
  805.         0,
  806.         guiBuffer);
  807.     /* Register function with right softkey */
  808.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  809.     /* Register Exit handler */
  810.     return;
  811. }
  814. /*****************************************************************************
  815.  * FUNCTION
  816.  *  EntryCALLSETBarringOption
  817.  * DESCRIPTION
  818.  *  entry function for call barring option menu
  819.  * NA
  820.  *  
  821.  * PARAMETERS
  822.  *  void
  823.  * RETURNS
  824.  *  void
  825.  *****************************************************************************/
  826. void EntryCALLSETBarringOption(void)
  827. {
  828.     /*----------------------------------------------------------------*/
  829.     /* Local Variables                                                */
  830.     /*----------------------------------------------------------------*/
  831.     //micha1229
  832.     //      U16 nDispAttribute; /* Stores display attribue */
  833.     U8 *guiBuffer;              /* Buffer holding history data */
  834.     U16 nNumofItem;
  835.     U16 nStrItemList[MAX_SUB_MENUS];
  837.     /*----------------------------------------------------------------*/
  838.     /* Code Body                                                      */
  839.     /*----------------------------------------------------------------*/
  840.     EntryNewScreen(SCR_ID_CALLSET_BARRING_OPTION, NULL, EntryCALLSETBarringOption, NULL);
  842.     /* Get current screen info into gui buffer  for history purposes */
  843.     guiBuffer = GetCurrGuiBuffer(SCR_ID_CALLSET_BARRING_OPTION);
  844.     /* Retrieve no of child of menu item to be displayed */
  845.     nNumofItem = GetNumOfChild(MENU_BARRING_OPTION);
  846.     /* Get attribute of menu to be displayed */
  847.     /* nDispAttribute = GetDispAttributeOfItem(MENU_BARRING_OPTION); */
  848.     /* Retrieve string ids in sequence of given menu item to be displayed */
  849.     GetSequenceStringIds(MENU_BARRING_OPTION, nStrItemList);
  850.     /* Set current parent id */
  851.     SetParentHandler(MENU_BARRING_OPTION);
  852.     /* Register highlight handler to be called in menu screen */
  853.     RegisterHighlightHandler(ExecuteCurrHiliteHandler);
  854.     /* Display Category Screen */
  855.     ShowCategory15Screen(
  856.         STR_MENU_BARRING_OPTION,
  857.         MAIN_MENU_TITLE_SETTINGS_ICON,
  858.         STR_GLOBAL_OK,
  859.         IMG_GLOBAL_OK,
  860.         STR_GLOBAL_BACK,
  861.         IMG_GLOBAL_BACK,
  862.         nNumofItem,
  863.         nStrItemList,
  864.         (U16*) gIndexIconsImageList,
  865.         1,
  866.         0,
  867.         guiBuffer);
  868.     /* Register function with right softkey */
  869.     SetRightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  870.     SetKeyHandler(GoBackHistory, KEY_LEFT_ARROW, KEY_EVENT_DOWN);
  871.     /* Register Exit handler */
  872.     return;
  873. }
  876. /*****************************************************************************
  877.  * FUNCTION
  878.  *  ScrBarringPasswordaValidation
  879.  * DESCRIPTION
  880.  *  validating the call barring passwords
  881.  * NA
  882.  *  
  883.  * PARAMETERS
  884.  *  text        [?]         
  885.  *  cursor      [?]         
  886.  *  length      [IN]        
  887.  * RETURNS
  888.  *  void
  889.  *****************************************************************************/
  890. void ScrBarringPasswordaValidation(U8 *text, U8 *cursor, S32 length)
  891. {
  892.     /*----------------------------------------------------------------*/
  893.     /* Local Variables                                                */
  894.     /*----------------------------------------------------------------*/
  896.     /*----------------------------------------------------------------*/
  897.     /* Code Body                                                      */
  898.     /*----------------------------------------------------------------*/
  899.     if ((length) < BARR_SIM_PASS_LEN)
  900.     {
  901.         ChangeLeftSoftkey(0, 0);
  902.     }
  903.     else
  904.     {
  905.         ChangeLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  906.         /* check the screen from which validation came */
  907.         switch (g_callset_context.SSBarPassStep)
  908.         {
  909.                 /* if the call barring options is selected */
  910.             case 0:
  911.             {
  912.                 SetLeftSoftkeyFunction(CallBarrOption, KEY_EVENT_UP);
  913.                 break;
  914.             }
  915.                 /* if the flow is from call barring new passwords screen */
  916.             case 1:
  917.             {
  918.                 SetLeftSoftkeyFunction(EntryCALLSETBarringNewPass, KEY_EVENT_UP);
  919.                 break;
  920.             }
  921.                 /* if the flow is from confirmation screen of call barring password screen */
  922.             case 2:
  923.             {
  924.                 SetLeftSoftkeyFunction(EntryCALLSETBarringCfrmPass, KEY_EVENT_UP);
  925.                 break;
  926.             }
  927.                 /* if the call barring options is selected */
  928.             case 3:
  929.             {
  930.                 SetLeftSoftkeyFunction(CallBarrOption, KEY_EVENT_UP);
  931.                 break;
  932.             }
  933.         }
  934.     }
  935.     return;
  936. }
  939. /*****************************************************************************
  940.  * FUNCTION
  941.  *  EntryCALLSETBarringPass
  942.  * DESCRIPTION
  943.  *  entry function for call barring passwd
  944.  * NA
  945.  *  
  946.  * PARAMETERS
  947.  *  void
  948.  * RETURNS
  949.  *  void
  950.  *****************************************************************************/
  951. void EntryCALLSETBarringPass(void)
  952. {
  953.     /*----------------------------------------------------------------*/
  954.     /* Local Variables                                                */
  955.     /*----------------------------------------------------------------*/
  956.     U8 *guiBuffer;
  958.     /*----------------------------------------------------------------*/
  959.     /* Code Body                                                      */
  960.     /*----------------------------------------------------------------*/
  961.     /* U8* inputBuffer; */
  963.     EntryNewScreen(SCR_ID_CALLSET_BARRING_PASS, NULL, EntryCALLSETBarringPass, NULL);
  965.     /* Get current screen info into gui buffer  for history purposes */
  966.     guiBuffer = GetCurrGuiBuffer(SCR_ID_CALLSET_BARRING_PASS);
  967.     /* inputBuffer = GetCurrInputBuffer(SCR_ID_CALLSET_BARRING_PASS); */
  969.     if (guiBuffer == NULL)
  970.     {
  971.         memset(g_callset_context.SSBarPassOld, 0, sizeof(g_callset_context.SSBarPassOld));
  972.     }
  973.     //      else
  974.     //              pfnUnicodeStrcpy((S8*)g_callset_context.SSBarPassOld, ( S8*)inputBuffer);
  976.     /* Register input validation function */
  977.     RegisterInputBoxValidationFunction(ScrBarringPasswordaValidation);
  978.     /* Display Category Screen */
  979.     ShowCategory111Screen(
  980.         STR_GLOBAL_OK,
  981.         IMG_GLOBAL_OK,
  982.         STR_GLOBAL_BACK,
  983.         IMG_GLOBAL_BACK,
  984.         STR_BARRING_PASSWORD_CAP,
  985.         INPUT_TYPE_NUMERIC_PASSWORD,
  986.         (PU8) g_callset_context.SSBarPassOld,
  987.         BARR_SIM_PASS_LEN + 1,
  988.         NULL,
  989.         guiBuffer);
  990.     /* Register function with left/right softkey */
  991.     SetLeftSoftkeyFunction(CallBarrOption, KEY_EVENT_UP);
  992.     SetCategory111RightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  993.     g_callset_context.SSBarPassStep = 0;
  994.     /* Register Exit handler */
  995.     return;
  996. }
  999. /*****************************************************************************
  1000.  * FUNCTION
  1001.  *  CallBarrOption
  1002.  * DESCRIPTION
  1003.  *  call barring options processing function
  1004.  * NA
  1005.  *  
  1006.  * PARAMETERS
  1007.  *  void
  1008.  * RETURNS
  1009.  *  void
  1010.  *****************************************************************************/
  1011. void CallBarrOption(void)
  1012. {
  1013.     /*----------------------------------------------------------------*/
  1014.     /* Local Variables                                                */
  1015.     /*----------------------------------------------------------------*/
  1017.     /*----------------------------------------------------------------*/
  1018.     /* Code Body                                                      */
  1019.     /*----------------------------------------------------------------*/
  1020.     /* menu option selected is call barring activate */
  1021.     if (g_callset_context.SSBarAction == BARRING_ON)
  1022.     {
  1023.         SendCallBarrActivate();
  1024.     }
  1025.     /* menu option selected is call barring deactivate */
  1026.     else if (g_callset_context.SSBarAction == BARRING_OFF)
  1027.     {
  1028.         SendCallBarrDeactivate();
  1029.     }
  1030.     /* menu option selected is call barring query status */
  1031.     else if (g_callset_context.SSBarAction == BARRING_QUERY)
  1032.     {
  1033.         SendBarrQuery();
  1034.     }
  1035.     /* menu option selected is call barring cancel all */
  1036.     else if (g_callset_context.SSBarAction == BARRING_CANCEL_ALL)
  1037.     {
  1038.         SendCancelAllReq();
  1039.     }
  1040.     /* menu option selected is call barring password change req */
  1041.     else if (g_callset_context.SSBarAction == BARRING_CHANGE_PSW)
  1042.     {
  1043.         SendChangePswdReq();
  1044.     }
  1045.     return;
  1046. }
  1049. /*****************************************************************************
  1050.  * FUNCTION
  1051.  *  SendCallBarrActivate
  1052.  * DESCRIPTION
  1053.  *  function to send req for call barring activate
  1054.  * NA
  1055.  *  
  1056.  * PARAMETERS
  1057.  *  void
  1058.  * RETURNS
  1059.  *  void
  1060.  *****************************************************************************/
  1061. void SendCallBarrActivate(void)
  1062. {
  1063.     /*----------------------------------------------------------------*/
  1064.     /* Local Variables                                                */
  1065.     /*----------------------------------------------------------------*/
  1067.     S8 input_string[(MAX_DIGITS_USSD * ENCODING_LENGTH)];
  1068.     PS8 hash_string = NULL;
  1069.     S8 string_out[20];
  1071.     /*----------------------------------------------------------------*/
  1072.     /* Code Body                                                      */
  1073.     /*----------------------------------------------------------------*/
  1074.     memset(string_out, 0, 20);
  1075.     /* format SS string for sending req to l4 */
  1076.     memset(input_string, 0, (MAX_DIGITS_USSD * ENCODING_LENGTH));
  1077.     hash_string = (PS8) GetString(STR_HASH_VALUE);
  1078.     switch (g_callset_context.SSBarType)
  1079.     {
  1080.             /* incase of call barring all outgoing calls */
  1081.         case BARRING_OUTGOING_ALLCALLS:
  1082.             strcpy((S8*) string_out, "*33*");
  1083.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1084.             break;
  1085.             /* incase of call barring all outgoing international calls */
  1086.         case BARRING_OUTGOING_INTERCALL:
  1087.             strcpy((S8*) string_out, "*331*");
  1088.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1089.             break;
  1090.             /* incase of call barring all outgoing international calls expect home */
  1091.         case BARRING_OUTGOING_INTEREXCEPTHOME:
  1092.             strcpy((S8*) string_out, "*332*");
  1093.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1094.             break;
  1095.             /* incase of call barring all incoming calls */
  1096.         case BARRING_INCOMING_ALLCALLS:
  1097.             strcpy((S8*) string_out, "*35*");
  1098.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1099.             break;
  1100.             /* incase of call barring all incoming roaming calls */
  1101.         case BARRING_INCOMING_ROAMING:
  1102.             strcpy((S8*) string_out, "*351*");
  1103.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1104.             break;
  1105.     }
  1106.     pfnUnicodeStrcat((PS8) input_string, (PS8) g_callset_context.SSBarPassOld);
  1107.     pfnUnicodeStrcat((PS8) input_string, (PS8) hash_string);
  1108.     /* set protocol event handler for the call barring response */
  1109.     SetProtocolEventHandler(CALLSETBarringRsp, PRT_MMI_SS_CALL_BARRING_RSP);
  1110.     /* make a corresponding ss string for call barring option */
  1111.     MakeCall((PS8) input_string);
  1112.     return;
  1113. }
  1116. /*****************************************************************************
  1117.  * FUNCTION
  1118.  *  SendCallBarrDeactivate
  1119.  * DESCRIPTION
  1120.  *  function to send req for call barring deactivate
  1121.  * NA
  1122.  *  
  1123.  * PARAMETERS
  1124.  *  void
  1125.  * RETURNS
  1126.  *  void
  1127.  *****************************************************************************/
  1128. void SendCallBarrDeactivate(void)
  1129. {
  1130.     /*----------------------------------------------------------------*/
  1131.     /* Local Variables                                                */
  1132.     /*----------------------------------------------------------------*/
  1133.     S8 input_string[(MAX_DIGITS_USSD * ENCODING_LENGTH)];
  1134.     PS8 hash_string = NULL;
  1135.     S8 string_out[20];
  1137.     /*----------------------------------------------------------------*/
  1138.     /* Code Body                                                      */
  1139.     /*----------------------------------------------------------------*/
  1140.     memset(string_out, 0, 20);
  1141.     /* format SS string for sending req to l4 */
  1142.     memset(input_string, 0, (MAX_DIGITS_USSD * ENCODING_LENGTH));
  1143.     hash_string = (PS8) GetString(STR_HASH_VALUE);
  1144.     switch (g_callset_context.SSBarType)
  1145.     {
  1146.             /* incase of call barring all outgoing calls */
  1147.         case BARRING_OUTGOING_ALLCALLS:
  1148.             strcpy((S8*) string_out, "#33*");
  1149.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1150.             break;
  1151.             /* incase of call barring all outgoing international calls */
  1152.         case BARRING_OUTGOING_INTERCALL:
  1153.             strcpy((S8*) string_out, "#331*");
  1154.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1155.             break;
  1156.             /* incase of call barring all outgoing international calls expect home */
  1157.         case BARRING_OUTGOING_INTEREXCEPTHOME:
  1158.             strcpy((S8*) string_out, "#332*");
  1159.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1160.             break;
  1161.             /* incase of call barring all incoming calls */
  1162.         case BARRING_INCOMING_ALLCALLS:
  1163.             strcpy((S8*) string_out, "#35*");
  1164.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1165.             break;
  1166.             /* incase of call barring all incoming roaming calls */
  1167.         case BARRING_INCOMING_ROAMING:
  1168.             strcpy((S8*) string_out, "#351*");
  1169.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_out);
  1170.             break;
  1171.     }
  1172.     pfnUnicodeStrcat((PS8) input_string, (PS8) g_callset_context.SSBarPassOld);
  1173.     pfnUnicodeStrcat((PS8) input_string, (PS8) hash_string);
  1174.     /* set protocol event handler for the call barring response */
  1175.     SetProtocolEventHandler(CALLSETBarringRsp, PRT_MMI_SS_CALL_BARRING_RSP);
  1176.     /* make a corresponding ss string for call barring option */
  1177.     MakeCall((PS8) input_string);
  1178.     return;
  1179. }
  1182. /*****************************************************************************
  1183.  * FUNCTION
  1184.  *  SendBarrQuery
  1185.  * DESCRIPTION
  1186.  *  function to send req for call barring query status.
  1187.  * NA
  1188.  *  
  1189.  * PARAMETERS
  1190.  *  void
  1191.  * RETURNS
  1192.  *  void
  1193.  *****************************************************************************/
  1194. void SendBarrQuery(void)
  1195. {
  1196.     /*----------------------------------------------------------------*/
  1197.     /* Local Variables                                                */
  1198.     /*----------------------------------------------------------------*/
  1199.     S8 input_string[(MAX_DIGITS_USSD * ENCODING_LENGTH)];
  1200.     S8 string_type[30];
  1202.     /*----------------------------------------------------------------*/
  1203.     /* Code Body                                                      */
  1204.     /*----------------------------------------------------------------*/
  1205.     /* format SS string for sending req to l4 */
  1206.     memset(input_string, 0, (MAX_DIGITS_USSD * ENCODING_LENGTH));
  1207.     memset(string_type, 0, 30);
  1208.     switch (g_callset_context.SSBarType)
  1209.     {
  1210.             /* incase of call barring all outgoing calls */
  1211.         case BARRING_OUTGOING_ALLCALLS:
  1212.             strcpy((S8*) string_type, "*#33#");
  1213.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_type);
  1214.             break;
  1215.             /* incase of call barring all outgoing international calls */
  1216.         case BARRING_OUTGOING_INTERCALL:
  1217.             strcpy((S8*) string_type, "*#331#");
  1218.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_type);
  1219.             break;
  1220.             /* incase of call barring all outgoing international calls expect home */
  1221.         case BARRING_OUTGOING_INTEREXCEPTHOME:
  1222.             strcpy((S8*) string_type, "*#332#");
  1223.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_type);
  1224.             break;
  1225.             /* incase of call barring all incoming calls */
  1226.         case BARRING_INCOMING_ALLCALLS:
  1227.             strcpy((S8*) string_type, "*#35#");
  1228.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_type);
  1229.             break;
  1230.             /* incase of call barring all incoming roaming calls */
  1231.         case BARRING_INCOMING_ROAMING:
  1232.             strcpy((S8*) string_type, "*#351#");
  1233.             AnsiiToUnicodeString((PS8) input_string, (PS8) string_type);
  1234.             break;
  1235.     }
  1236.     /* set protocol event handler for the call barring response */
  1237.     SetProtocolEventHandler(CALLSETBarringRsp, PRT_MMI_SS_CALL_BARRING_RSP);
  1238.     /* make a corresponding ss string for call barring option */
  1239.     MakeCall((PS8) input_string);
  1240.     return;
  1241. }
  1244. /*****************************************************************************
  1245.  * FUNCTION
  1246.  *  CALLSETBarringRsp
  1247.  * DESCRIPTION
  1248.  *  function for handling response for call barring query req.
  1249.  * NA
  1250.  *  
  1251.  * PARAMETERS
  1252.  *  info        [?]     
  1253.  * RETURNS
  1254.  *  void
  1255.  *****************************************************************************/
  1256. void CALLSETBarringRsp(void *info)
  1257. {
  1258.     /*----------------------------------------------------------------*/
  1259.     /* Local Variables                                                */
  1260.     /*----------------------------------------------------------------*/
  1262.     mmi_ss_call_barring_rsp_struct *pMsgBarringRsp = (mmi_ss_call_barring_rsp_struct*) info;
  1263.     U8 bs_index;
  1265.     /*----------------------------------------------------------------*/
  1266.     /* Code Body                                                      */
  1267.     /*----------------------------------------------------------------*/
  1268.     memset(g_callset_context.SSDisplayBuffer, 0, MAX_DISP_UCS2);
  1270.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_OUT);
  1271.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_IN);
  1272.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_PASS);
  1273.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_OLD_PASS);
  1274.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_OPTION);
  1275.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_NEW_PASS);
  1276.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_CFRM_PASS);
  1278.     /* check the status of the response result */
  1279.     if (pMsgBarringRsp->result.flag == L4C_OK)
  1280.     {
  1281.         /* if the response is success check the type */
  1282.         switch (pMsgBarringRsp->type)
  1283.         {
  1284.                 /* call barring all outgoing calls */
  1285.             case L4_BAOC:
  1286.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_BAOC_A));
  1287.                 break;
  1288.                 /* call barring all outgoing international calls */
  1289.             case L4_BOIC:
  1290.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_BOIC_A));
  1291.                 break;
  1292.                 /* call barring all outgoing international calls except home */
  1293.             case L4_BOICEXHC:
  1294.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_BOICEXHC_A));
  1295.                 break;
  1296.                 /* call barring all incoming calls */
  1297.             case L4_BAIC:
  1298.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_BAIC_A));
  1299.                 break;
  1300.                 /* call barring all incoming roaming calls */
  1301.             case L4_BAICROAM:
  1302.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_BAICROAM_A));
  1303.                 break;
  1304.                 /* call barring cancel all calls */
  1305.             case L4_BAC:
  1306.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_BAC_A));
  1307.                 break;
  1308.                 /* call barring all outgoing calls */
  1309.             case L4_BOC:
  1310.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_BOC_A));
  1311.                 break;
  1312.                 /* call barring all incoming calls */
  1313.             case L4_BIC:
  1314.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_BIC_A));
  1315.                 break;
  1316.             default:
  1317.                 pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_DEFAULT_A));
  1318.                 break;
  1319.         }
  1320.         /* format the result string with active/deactive tags. */
  1321.         if (pMsgBarringRsp->count == 0)
  1322.         {
  1323.             pfnUnicodeStrcat((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_DEACTIVATED));
  1324.         }
  1325.         for (bs_index = 0; bs_index < pMsgBarringRsp->count; bs_index++)
  1326.         {
  1327.             if ((pfnUnicodeStrlen((PS8) GetString(STR_L4_ALL_TELESERVICES_EXCEPT_SMS))
  1328.                  + pfnUnicodeStrlen((PS8) GetString(STR_DEACTIVATED))
  1329.                  + pfnUnicodeStrlen((PS8) g_callset_context.SSDisplayBuffer)) < MAX_DISP_UCS2 / ENCODING_LENGTH)
  1330.             {
  1331.                 if (pMsgBarringRsp->list[bs_index].ss_status & SS_ABIT)
  1332.                 {
  1333.                     pfnUnicodeStrcat((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_ACTIVATED));
  1334.                 }
  1335.                 else if (pMsgBarringRsp->list[bs_index].ss_status & SS_PBIT)
  1336.                 {
  1337.                     pfnUnicodeStrcat((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_DEACTIVATED));
  1338.                 }
  1339.                 else
  1340.                 {
  1341.                     pfnUnicodeStrcat((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_NOT_PROVIDED));
  1342.                 }
  1343.                 AppendBScodeString(pMsgBarringRsp->list[bs_index].bs_code, (PS8) g_callset_context.SSDisplayBuffer);
  1344.             }
  1345.         }
  1346.         /* call the result screen function to display the result string */
  1347.         /* micha0322 */
  1348.         DeleteScreenIfPresent(SCR_ID_CALLSET_GENERAL_SS_RESULT);
  1349.         EntryCALLSETGeneralSSResut();
  1350.     }
  1351.     else
  1352.     {
  1353.         /* in case of response failure */
  1354.     #ifdef __MMI_SS_SHOW_CAUSE__
  1355.         ShowCauseString(pMsgBarringRsp->result.cause, (PS8) g_callset_context.SSDisplayBuffer);
  1356.         /* micha0322 */
  1357.         DeleteScreenIfPresent(SCR_ID_CALLSET_GENERAL_SS_RESULT);
  1358.         EntryCALLSETGeneralSSResut();
  1359.     #else /* __MMI_SS_SHOW_CAUSE__ */ 
  1360.         /* display the not done popup */
  1361.         /* micha0616 */
  1362.         if (pMsgBarringRsp->result.cause == CM_SS_ERR_NEGATIVEPW_CHECK)
  1363.         {
  1364.             DisplayPopup((PU8) GetString(STR_SETTING_WRONG), IMG_GLOBAL_UNFINISHED, 0, CS_NOTIFYDURATION, ERROR_TONE);
  1365.         }
  1366.         else if (pMsgBarringRsp->result.cause == CM_SS_ERR_NUMBEROFPW_ATTEMPTSVIOLATION)
  1367.         {
  1368.             DisplayPopup((PU8) GetString(STR_SETTING_BLOCK), IMG_GLOBAL_UNFINISHED, 0, CS_NOTIFYDURATION, ERROR_TONE);
  1369.         }
  1370.         else
  1371.         {
  1372.             DisplayPopup((PU8) GetString(STR_GLOBAL_NOT_DONE), IMG_GLOBAL_UNFINISHED, 0, CS_NOTIFYDURATION, ERROR_TONE);
  1373.         }
  1375.         /* micha0915 */
  1376.         RemoveSSReqScr();
  1377.     #endif /* __MMI_SS_SHOW_CAUSE__ */ 
  1378.     }
  1379.     return;
  1380. }
  1383. /*****************************************************************************
  1384.  * FUNCTION
  1385.  *  SendCancelAllReq
  1386.  * DESCRIPTION
  1387.  *  function for sending req for cancel all (call barring) .
  1388.  * NA
  1389.  *  
  1390.  * PARAMETERS
  1391.  *  void
  1392.  * RETURNS
  1393.  *  void
  1394.  *****************************************************************************/
  1395. void SendCancelAllReq(void)
  1396. {
  1397.     /*----------------------------------------------------------------*/
  1398.     /* Local Variables                                                */
  1399.     /*----------------------------------------------------------------*/
  1400.     U8 input_string[MAX_DIGITS_USSD];
  1401.     PS8 hash_string = NULL;
  1402.     U8 string_type[20];
  1404.     /*----------------------------------------------------------------*/
  1405.     /* Code Body                                                      */
  1406.     /*----------------------------------------------------------------*/
  1407.     /* format the string for the ss string handling */
  1408.     memset(input_string, 0, MAX_DIGITS_USSD);
  1409.     memset(string_type, 0, 20);
  1410.     hash_string = (PS8) GetString(STR_HASH_VALUE);
  1411.     strcpy((PS8) string_type, (PS8) "#330*");
  1412.     AnsiiToUnicodeString((PS8) input_string, (PS8) string_type);
  1413.     pfnUnicodeStrcat((S8*) input_string, (S8*) g_callset_context.SSBarPassOld);
  1414.     pfnUnicodeStrcat((S8*) input_string, (S8*) hash_string);
  1415.     /* make a corresponding ss string for call fwd option */
  1416.     MakeCall((PS8) input_string);
  1417.     return;
  1418. }
  1421. /*****************************************************************************
  1422.  * FUNCTION
  1423.  *  SendChangePswdReq
  1424.  * DESCRIPTION
  1425.  *  function for sending req for call barring change passwd.
  1426.  * NA
  1427.  *  
  1428.  * PARAMETERS
  1429.  *  void
  1430.  * RETURNS
  1431.  *  void
  1432.  *****************************************************************************/
  1433. void SendChangePswdReq(void)
  1434. {
  1435.     /*----------------------------------------------------------------*/
  1436.     /* Local Variables                                                */
  1437.     /*----------------------------------------------------------------*/
  1438.     U8 input_string[MAX_DIGITS_USSD];
  1439.     U8 string_type[20];
  1440.     PS8 hash_string = NULL;
  1441.     U8 uni_string[10];
  1443.     /*----------------------------------------------------------------*/
  1444.     /* Code Body                                                      */
  1445.     /*----------------------------------------------------------------*/
  1446.     memset(uni_string, 0, 10);
  1447.     /* format the string for the ss string handling */
  1448.     memset(input_string, 0, MAX_DIGITS_USSD);
  1449.     memset(string_type, 0, 20);
  1450.     strcpy((PS8) string_type, (PS8) "*03**");
  1451.     hash_string = (PS8) GetString(STR_HASH_VALUE);
  1452.     AnsiiToUnicodeString((PS8) input_string, (PS8) string_type);
  1453.     pfnUnicodeStrcat((PS8) input_string, (PS8) g_callset_context.SSBarPassOld);
  1454.     strcpy((PS8) string_type, (PS8) "*");
  1455.     AnsiiToUnicodeString((PS8) uni_string, (PS8) string_type);
  1456.     pfnUnicodeStrcat((PS8) input_string, (PS8) uni_string);
  1457.     pfnUnicodeStrcat((PS8) input_string, (PS8) g_callset_context.SSBarPassNew);
  1458.     pfnUnicodeStrcat((PS8) input_string, (PS8) uni_string);
  1459.     pfnUnicodeStrcat((PS8) input_string, (PS8) g_callset_context.SSBarPassCfrm);
  1460.     pfnUnicodeStrcat((PS8) input_string, (PS8) hash_string);
  1461.     /* set protocol event handler for the call barring passwd change response */
  1462.     SetProtocolEventHandler(CALLSETBarringPassRsp, PRT_MMI_SS_CHANGE_PASSWORD_RSP);
  1463.     /* make a corresponding ss string for call barring passwd change response option */
  1464.     MakeCall((PS8) input_string);
  1465.     return;
  1466. }
  1469. /*****************************************************************************
  1470.  * FUNCTION
  1471.  *  CALLSETBarringPassRsp
  1472.  * DESCRIPTION
  1473.  *  function for handling response for call barring change passwd req.
  1474.  * NA
  1475.  *  
  1476.  * PARAMETERS
  1477.  *  info        [?]     
  1478.  * RETURNS
  1479.  *  void
  1480.  *****************************************************************************/
  1481. void CALLSETBarringPassRsp(void *info)
  1482. {
  1483.     /*----------------------------------------------------------------*/
  1484.     /* Local Variables                                                */
  1485.     /*----------------------------------------------------------------*/
  1486.     mmi_ss_call_barring_rsp_struct *pMsgBarringRsp = (mmi_ss_call_barring_rsp_struct*) info;
  1488.     /*----------------------------------------------------------------*/
  1489.     /* Code Body                                                      */
  1490.     /*----------------------------------------------------------------*/
  1491.     /* change passwd response handling */
  1492.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_OUT);
  1493.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_IN);
  1494.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_PASS);
  1495.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_OLD_PASS);
  1496.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_OPTION);
  1497.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_NEW_PASS);
  1498.     DeleteScreenIfPresent(SCR_ID_CALLSET_BARRING_CFRM_PASS);
  1500.     if (pMsgBarringRsp->result.flag == 0)
  1501.     {
  1502.         pfnUnicodeStrcpy((PS8) g_callset_context.SSDisplayBuffer, (PS8) GetString(STR_CHANGE_PSW_SUCCESS_TEXT));
  1503.         /* micha0322 */
  1504.         DeleteScreenIfPresent(SCR_ID_CALLSET_GENERAL_SS_RESULT);
  1505.         EntryCALLSETGeneralSSResut();
  1506.     }
  1507.     else
  1508.     {
  1510.         /* micha0616 */
  1511.         if (pMsgBarringRsp->result.cause == CM_SS_ERR_NEGATIVEPW_CHECK)
  1512.         {
  1513.             DisplayPopup((PU8) GetString(STR_SETTING_WRONG), IMG_GLOBAL_UNFINISHED, 0, CS_NOTIFYDURATION, ERROR_TONE);
  1514.         }
  1515.         else if (pMsgBarringRsp->result.cause == CM_SS_ERR_NUMBEROFPW_ATTEMPTSVIOLATION)
  1516.         {
  1517.             DisplayPopup((PU8) GetString(STR_SETTING_BLOCK), IMG_GLOBAL_UNFINISHED, 0, CS_NOTIFYDURATION, ERROR_TONE);
  1518.         }
  1519.         else
  1520.         {
  1521.             DisplayPopup((PU8) GetString(STR_GLOBAL_NOT_DONE), IMG_GLOBAL_UNFINISHED, 0, CS_NOTIFYDURATION, ERROR_TONE);
  1522.         }
  1524.         /* micha0915 */
  1525.         RemoveSSReqScr();
  1526.     }
  1527.     return;
  1528. }
  1531. /*****************************************************************************
  1532.  * FUNCTION
  1533.  *  EntryCALLSETBarringOldPass
  1534.  * DESCRIPTION
  1535.  *  entry function for call barring old passwd screen
  1536.  * NA
  1537.  *  
  1538.  * PARAMETERS
  1539.  *  void
  1540.  * RETURNS
  1541.  *  void
  1542.  *****************************************************************************/
  1543. void EntryCALLSETBarringOldPass(void)
  1544. {
  1545.     /*----------------------------------------------------------------*/
  1546.     /* Local Variables                                                */
  1547.     /*----------------------------------------------------------------*/
  1548.     U8 *guiBuffer;
  1550.     /*----------------------------------------------------------------*/
  1551.     /* Code Body                                                      */
  1552.     /*----------------------------------------------------------------*/
  1553.     /* U8 * inputBuffer; */
  1555.     EntryNewScreen(SCR_ID_CALLSET_BARRING_OLD_PASS, NULL, EntryCALLSETBarringOldPass, NULL);
  1557.     /* Get current screen info into gui buffer  for history purposes */
  1558.     guiBuffer = GetCurrGuiBuffer(SCR_ID_CALLSET_BARRING_OLD_PASS);
  1559.     /* inputBuffer = GetCurrInputBuffer(SCR_ID_CALLSET_BARRING_OLD_PASS); */
  1560.     if (guiBuffer == NULL)
  1561.     {
  1562.         memset(g_callset_context.SSBarPassOld, 0, sizeof(g_callset_context.SSBarPassOld));
  1563.     }
  1564.     //      else
  1565.     //              pfnUnicodeStrcpy((S8*)g_callset_context.SSBarPassOld, ( S8*)inputBuffer);
  1566.     /* Register input validation function */
  1567.     RegisterInputBoxValidationFunction(ScrBarringPasswordaValidation);
  1568.     /* display the corresponding screen */
  1569.     ShowCategory111Screen(
  1570.         STR_GLOBAL_OK,
  1571.         IMG_GLOBAL_OK,
  1572.         STR_GLOBAL_BACK,
  1573.         IMG_GLOBAL_BACK,
  1574.         STR_OLD_BARRINGPASS_CAP,
  1575.         INPUT_TYPE_NUMERIC_PASSWORD,
  1576.         (PU8) g_callset_context.SSBarPassOld,
  1577.         BARR_SIM_PASS_LEN + 1,
  1578.         NULL,
  1579.         guiBuffer);
  1580.     /* Set the left/right soft key funtions */
  1581.     SetLeftSoftkeyFunction(EntryCALLSETBarringNewPass, KEY_EVENT_UP);
  1582.     SetCategory111RightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1583.     g_callset_context.SSBarPassStep = 1;
  1585. }
  1588. /*****************************************************************************
  1589.  * FUNCTION
  1590.  *  EntryCALLSETBarringNewPass
  1591.  * DESCRIPTION
  1592.  *  entry function for call barring new passwd screen
  1593.  * NA
  1594.  *  
  1595.  * PARAMETERS
  1596.  *  void
  1597.  * RETURNS
  1598.  *  void
  1599.  *****************************************************************************/
  1600. void EntryCALLSETBarringNewPass(void)
  1601. {
  1602.     /*----------------------------------------------------------------*/
  1603.     /* Local Variables                                                */
  1604.     /*----------------------------------------------------------------*/
  1606.     U8 *guiBuffer;
  1608.     /*----------------------------------------------------------------*/
  1609.     /* Code Body                                                      */
  1610.     /*----------------------------------------------------------------*/
  1611.     /* U8 * inputBuffer; */
  1613.     EntryNewScreen(SCR_ID_CALLSET_BARRING_NEW_PASS, NULL, EntryCALLSETBarringNewPass, NULL);
  1615.     /* Get current screen info into gui buffer  for history purposes */
  1616.     guiBuffer = GetCurrGuiBuffer(SCR_ID_CALLSET_BARRING_NEW_PASS);
  1617.     /* inputBuffer = GetCurrInputBuffer(SCR_ID_CALLSET_BARRING_NEW_PASS); */
  1618.     if (guiBuffer == NULL)
  1619.     {
  1620.         memset(g_callset_context.SSBarPassNew, 0, sizeof(g_callset_context.SSBarPassNew));
  1621.     }
  1622.     //      else
  1623.     //              pfnUnicodeStrcpy((S8*)g_callset_context.SSBarPassNew, ( S8*)inputBuffer);
  1624.     /* Register input validation function */
  1625.     RegisterInputBoxValidationFunction(ScrBarringPasswordaValidation);
  1626.     /* display the corresponding screen */
  1627.     ShowCategory111Screen(
  1628.         STR_GLOBAL_OK,
  1629.         IMG_GLOBAL_OK,
  1630.         STR_GLOBAL_BACK,
  1631.         IMG_GLOBAL_BACK,
  1632.         STR_NEW_BARRINGPASS_CAP,
  1633.         INPUT_TYPE_NUMERIC_PASSWORD,
  1634.         (PU8) g_callset_context.SSBarPassNew,
  1635.         BARR_SIM_PASS_LEN + 1,
  1636.         NULL,
  1637.         guiBuffer);
  1638.     g_callset_context.SSBarPassStep = 2;
  1639.     /* Set the left/right soft key funtions */
  1640.     SetLeftSoftkeyFunction(EntryCALLSETBarringCfrmPass, KEY_EVENT_UP);
  1641.     SetCategory111RightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1642.     return;
  1643. }
  1646. /*****************************************************************************
  1647.  * FUNCTION
  1648.  *  EntryCALLSETBarringCfrmPass
  1649.  * DESCRIPTION
  1650.  *  entry function for call barring change passwd confirmation screen
  1651.  * NA
  1652.  *  
  1653.  * PARAMETERS
  1654.  *  void
  1655.  * RETURNS
  1656.  *  void
  1657.  *****************************************************************************/
  1658. void EntryCALLSETBarringCfrmPass(void)
  1659. {
  1660.     /*----------------------------------------------------------------*/
  1661.     /* Local Variables                                                */
  1662.     /*----------------------------------------------------------------*/
  1663.     U8 *guiBuffer;
  1665.     /*----------------------------------------------------------------*/
  1666.     /* Code Body                                                      */
  1667.     /*----------------------------------------------------------------*/
  1668.     /* U8 * inputBuffer; */
  1670.     EntryNewScreen(SCR_ID_CALLSET_BARRING_CFRM_PASS, NULL, EntryCALLSETBarringCfrmPass, NULL);
  1672.     /* Get current screen info into gui buffer  for history purposes */
  1673.     guiBuffer = GetCurrGuiBuffer(SCR_ID_CALLSET_BARRING_CFRM_PASS);
  1674.     /* inputBuffer = GetCurrInputBuffer(SCR_ID_CALLSET_BARRING_CFRM_PASS); */
  1675.     if (guiBuffer == NULL)
  1676.     {
  1677.         memset(g_callset_context.SSBarPassCfrm, 0, sizeof(g_callset_context.SSBarPassCfrm));
  1678.     }
  1679.     //      else
  1680.     //              pfnUnicodeStrcpy((S8*)g_callset_context.SSBarPassCfrm, ( S8*)inputBuffer);
  1681.     /* Register input validation function */
  1682.     RegisterInputBoxValidationFunction(ScrBarringPasswordaValidation);
  1683.     /* display the corresponding screen */
  1684.     ShowCategory111Screen(
  1685.         STR_GLOBAL_OK,
  1686.         IMG_GLOBAL_OK,
  1687.         STR_GLOBAL_BACK,
  1688.         IMG_GLOBAL_BACK,
  1689.         STR_CONFIRM_BARRINGPASS_CAP,
  1690.         INPUT_TYPE_NUMERIC_PASSWORD,
  1691.         (PU8) g_callset_context.SSBarPassCfrm,
  1692.         BARR_SIM_PASS_LEN + 1,
  1693.         NULL,
  1694.         guiBuffer);
  1695.     g_callset_context.SSBarPassStep = 3;
  1696.     /* Set the left/right soft key funtions */
  1697.     SetLeftSoftkeyFunction(CallBarrOption, KEY_EVENT_UP);
  1698.     SetCategory111RightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1699.     return;
  1700. }