view src/ui3/bmi/mmiPins.c @ 599:4626d7a955de

aci3 MCSI autoswitch: RV return path fix
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 28 Mar 2019 00:01:11 +0000
parents 6a4d9f47793e
children
line wrap: on
line source


/*******************************************************************************

					CONDAT (UK) 

********************************************************************************									      

 This software product is the property of Condat (UK) Ltd and may not be
 disclosed to any third party without the express permission of the owner.				   
									      
********************************************************************************

 $Project name: Basic MMI						       
 $Project code: BMI (6349)							     
 $Module:		MMI
 $File: 	    MmiPins.c
 $Revision:		1.0							  
									      
 $Author:		Condat(UK)							   
 $Date: 	    25/10/00							  
									       
********************************************************************************
									      
 Description:
 
  MMI PIN / PUK entry handling
			
********************************************************************************

 $History: MmiPins.c

	May 24, 2007  DR: OMAPS00132483 x0pleela
	Description: MM: While playing an AAC, unplug USB freezes the audio
	Solution: If any Audio file is playing, then stopping them before enabling/disabling phone lock,
				auto phone lock and changing unlock password.
			Changed the name of fucntions for setting and restting the headset/usb bit in 
				ph_lock status variable
	
 	May 23, 2007    DR: OMAPS00127483  x0pleela
	Description:   Phonelock - Unable to unlock the phone during incoming call with ringer...
	Solution: 	When ringer for either incoming call or alarm is playing in phone locked state, Audio 
			usues the DMA channels which will be active. The DMA channels will be available only 
			after the audio file is fully played. This will cause that process to be blocked until the 
			DMA channel becomes in-active and in turn if we try to query or access secure driver 
			we are blocked until the audio file is completely played. Since this is a hardware 
			constraint, we found a workaround for this issue and are stopping the ringer  
			either for incoming call or alarm before accessing secure driver for enabling or 
			disbaling the phone lock.

	May 09, 2007  DR: OMAPS00129014
	Description: COMBO: unable to send SMS during midi playing
	Solution: Setting the auto phone lock flag to TRUE / FALSE when automatic phonelock is 
				on / off respectively	
	
	Apr 03, 2007    ER: OMAPS00122561  x0pleela
	Description:   [ACI] Phone lock feature has to be supported by ACI
	Solution: Phone Lock ER implementation 

      Feb 19, 2006 ER:OMAPS00115179 a0393213
      Description : support SIM insertion without powering down
      Solution	   : Unnecessary windows cleared during SIM insertion

 	Nov 13, 2006 DR: OMAPS00103356  x0pleela
 	Description: SIMP:Master unlock failed through MMI
 	Solution: 1) In function pins_editor_cb() for INPUT_MASTER_KEY_REQ, 
			- An event SMLK_SHOW_WRONG_PWD is sent for wrong Master unlock password
			- An event SMLK_SHOW_DEP_CATS_UNLOCKED is sent which says all the dependent 
				categories are unlocked
			2) In function pin_messages(): 
 			- An event SMLK_SHOW_WRONG_PWD is handled to display a dialog saying Master 
 				Unblock Password is wrong
			- An event SMLK_SHOW_DEP_CATS_UNLOCKED to display a dialog saying Master 
				unlocking operation is successful

    	Sep 26, 2006 DR: OMAPS00095524 x0pleela
 	Description:Implement 2 missing SIM Lock types
 	Solution: Made the following changes
			1) sim_event_cb_main()
				- Handling the event MFW_SIM_PBLOCK_REQ for requesting unlocking password 
					of "Blocked Network" category
			2) simp_busy_cb()
				- Added a check for CME class and Ext class and handled all CME errors 
					and EXT errors separately
			3) pin_main()
				- Handling the event INPUT_PBLOCK_PIN_REQ to prompt the user to enter the 
					Blocked Network Password (PIN or PUK)
			4) pin_info_cb()
				- Added a check for CME class and Ext class and handled all CME errors and EXT 
					errors separately for event SMLK_MASTERKEY and SMLK_PUK
			5) simlock_check_PBCatLock()
				- Added new function which gets the lock status of Blocked Network category 
					and accordingly display the menu item
			6) simp_unlock_Category()
				- Handling "Blocked Network" category and send INPUT_PBLOCK_PIN_REQ event
			7) setLockTypePb()
				- Added new function which sets the global flag to the Personalisation lock
			8) set_pin_messages()
				- Updating the variable which prompts the user to enter Blocked Network password
			9) pins_editor_cb()
				- Handling the event INPUT_PBLOCK_PIN_REQ fr Blocked Network category
				- Added a check for CME class and Ext class and handled all CME errors and EXT 
					errors separately
 	
 	Sep 26, 2006 DR: OMAPS00096565  x0pleela
 	Description: After blocking PIN, when ISAMPLE is reset, instead of prompting for PUK, master 
 				unlock key is asked
 	Solution: Added a check for C_KEY_REQ in functions sim_event_cb_main(), pin_info_cb() .
 			If this variable is set the SIMP menu will be isplayed 
 			else user wil be prompted to enter PUK
 

 	xashmic 21 Sep 2006, OMAPS00095831
 	Description: USB enumeration does not happen in PIN/PUK/Insert SIM scenarios
 	Solution: When booting up without SIM card, or prompting for PIN/PUK/SIMP entry, 
 	enumerate all the USB ports automatically 
 	
 	Sep 11, 2006 DR: OMAPS00094215  x0pleela
 	Description: MMI compilation failed as CME_ErrBusy undefined
 	Solution: Handling new Ext_ERR_Busy sent by ACI

 	Sep 08, 2006 DR: OMAPS00091250 x0pleela
 	Description:The phone resets if no MEPD data is presented
 	Solution:  - Handling MFW_MEPD_INVALID event in function sim_event_cb_main()
			- Handling NO_MEPD event in functions pin_main(), pin_edt_kbd_cb(), check_pins(), 
				pin_editor(), pin_messages(), check_set_pins(), pins_editor_cb(), show_confirmation_cb()

	July 31, 2006 ER: OMAPS00087586, OMAPS00087587 x0pleela
	Description: 	OMAPS00087586: MasterKey funtion in TCS3.2 SW
				OMAPS00087587: Time Penaly feature extend handset security
	Solution:Made the following changes
	1) Added new element mk_pin to store Master Unlock key to T_Pin structure
	2) pin_main(), pin_messages(), setting_pin_main(),set_pin_messages(): Added new event SIM_LOCK_BUSY_UNBLOCK 
		to display a dialog "Busy" when wrong unlock password is entered after 1st attempt if timer is running
	3) pin_info_cb(): Handling CME_ERR_Busy 
	4) mmi_simlock_reset_fc_value(), pins_editor_cb(): Handling CME_ERR_Busy error and sending new event 
		SIM_LOCK_BUSY_UNBLOCK 	to display a dialog "Busy" when wrong unlock password 
		is entered after 1st attempt if timer is running
	
	July 21, 2006 ER: OMAPS00087586, OMAPS00087587 x0pleela
	Description: 	OMAPS00087586: MasterKey funtion in TCS3.2 SW
				OMAPS00087587: Time Penaly feature extend handset security
				
	Solution:Made the following changes
	1) sim_event_cb_main(): check for Master Unlock option enabled. If so, then display the menu 
				  with options Unblock ME and Master Unlock. Similar for all the categories also.
	2) pin_main(): 	
		a) Handling SIM_LOCK_BUSY_BOOTUP event which displays a dialog "Busy" for the user 
			if timer is enabled and ACI returns Busy error when user had entered wrong unlocking 
			password
		b) Handling events SMLK_SHOW_MK_FAIL for wrong master unlock key, 
			SMLK_SHOW_MK_SUCC for correct master unlock key

	3) pin_messages(): 
		a) Handling event SMLK_SHOW_MK_FAIL to show a dialog saying "Master Unlock Failed"
		b) Handling event SMLK_SHOW_MK_SUCC to show a dialog saying "Master Unlock Success"
		c) For event SMLK_SHOW_FC_SUCC, changed the event from PIN_OK to SMLK_PUK bcoz 
			after unblocking ME, for event PIN_OK it would go to idle screen without displaying 
			menu for unlocking any categories if any
		d) Delete the simp_list window handler after displaying the dialog immaterial of whether 
			the unlock/unblock passwords are correct or not

	4) pin_info_cb():	
		a) Handling PUK1_REQ separately as a menu should be displayed for Unblocking ME and 
			Master Unlock
		b) Handling SMLK_MASTERKEYto display menu for Unblocking ME or unlocking categories 
			if any and Master Unlock
		c) Made changes in the code for event SMLK_PUK to display menu Unblocking ME or 
			unlocking categories if any and Master Unlock

	5) setting_pin_main():
		a) Handling event SIM_LOCK_REQ_MKPWD for Master unlock ket request
		b) Handling event SIM_LOCK_MKPWD_FAIL for Master unlocking failed
		c) Handling event SIM_LOCK_MKPWDSUCC for Master unlocking success
		d) Handling new event SIM_LOCK_BUSY to display a dialog Busy for wrong entry of 
			unlocking pwd and timer been enable

	6) mmi_display_result(): Handling CME error busy while unlocking a locked category and send 
		SIM_LOCK_BUSY event

	7) mmi_simlock_en_dis_verify(): Handling CME error busy while unlocking a locked category 
		and send SIM_LOCK_BUSY event

	8) set_pin_editor(): Handling event INPUT_SIM_MKPWD

	9) set_pin_kbd_cb(): Handling event INPUT_SIM_MKPWD

	10) set_pin_messages(): Handling events SIM_LOCK_MKPWD_FAIL for Master unlock failed, 
		SIM_LOCK_MKPWDSUCC for Master unlock success, SIM_LOCK_BUSY for category unlock 
		return with Busy error from ACI

	11) pins_editor_cb(): 
		a) Update mmi_simlock_aciErrDesc with the latest CME error
		b) Event INPUT_MASTER_KEY_REQ performs master unlock and sends corresponding 
			events during bootup
		c) Delete the simp list window handler immaterial of whether the unlock/unblock
			passwords are correct or not
		d) Get the busy state "Simp_Busy_State" and send event to display a dialog Busy 
			for the user
		e) Check for Master Unlock option enabled. If so, then display the menu with options 
			<Category> unlock and Master Unlock

	12) Added following new functions:
		a) simp_busy_cb: This function checks for the ACI CME error and display menu for 
			unlocking  categories or unblocking ME
		b) mmi_simlock_category_menus: Starts the simlock category list menu
		c) SIMLock_unblock_ME: This function sends an event to display an editor for the user to 
			enter unblocking code
		d) SIMLock_MasterKeyUnlock_bootup: This functioh gets called to unlock category /unblock 
			ME during bootup sequence
		e) SIMLock_MasterKeyUnlock: This functioh gets called to unlock category /unblock ME 
			through SIMP menu
		f) simlock_check_masterkey: If there is no support for Master Unlocking the item "Master unlock"
			will not appear on the menulist
		g) simlock_get_masterkey_status: This function gets the master key status
		h) simlock_check_NWCatLock: This function gets the lock status of Network category and 
			accordingly display the menu item
		i) simlock_check_NSCatLock: This function gets the lock status of Network subset category and 
			accordingly display the menu item
		j) simlock_check_SPCatLock: This function gets the lock status of Service Provider category and 
			accordingly display the menu item
		k) simlock_check_CPCatLock: This function gets the lock status of Corporate category and 
			accordingly display the menu item
		l) simlock_check_SIMCatLock: This function gets the lock status of SIM category and accordingly 
			display the menu item
		m) simlock_check_CatBlock: This function gets  the ME status and accordingly display the menu item
		n) mmi_simlock_master_unlock: This function unlocks category/unblocks ME and sends event 
			accordingly through SIMP menu
		o) simp_unlock_Category: This function sends corresponding event to unlock a locked category 
			through dynamic menu

       July 11, 2006    DR: OMAPS00084081   x0039928
       Descripton: CT-GCF-LL[27.22.4.7.2]-No IMSI attched request after SIM reset
       Solution: Network registration is initiated on sim reset.

	July 05, 2006    DR: OMAPS00084642   x0pleela
       Descripton: SIMP: we can unlock category with invalid password (more than 16 digit)
       Solution: Changed the size of simlock password enty from MAX_DIG to MAX_PIN+1
       
    xreddymn 4, Jul, 2006 OMAPS00083495
    Resolved issues reported in PIN and PUK input through BPM.

       June 07, 2006    DR: OMAPS00080701   x0021334
       Descripton: Phone hangs while unblocking SIMP during bootup.
       Solution: The assignment of  'SIMP_BOOTUP' to 'sim_unlock_in_prog' to indicate that
       the operation is happeneing during boot-up sequence was not taking place since the 
       respective function was not being called when SIMP was blocked and re-boot was done.
       This has now been corrected.

	xrashmic 6 Jul, 2006 OMAPS00080708
	The pin window is necessary for displaying the error message for MFW_SS_FAIL

	xrashmic 1 Jul, 2006 OMAPS00075784
       Fixed the blue screen issue in pin, pin2 and simp scenarios
	
	May 15, 2006 DR:OMAPS00067919 x0pleela
	Description: SIMP:On repeat Depersonalisation with invalid password MEPD unblock key should 
				be asked not Puk1.
	Solution: Made the following changes
			Function: pin_main()
					1. Change the text display based on the PUK1 or Unblock code request
					2. Added code to close the editor on PIN_OK_END event
			Function: pins_editor_cb()
					1. Modified the code to check SIMP during bootup sequence

 	Apr 19, 2006 DR:OMAPS00067912 x0pleela
	Description: SIMP:On repeat Depersonalisation with invalid password MEPD unblock key should 
				be asked not Puk1.
	Solution: Made changes in the functions sim_event_cb_main(), pin_main(), pin_messages(), 
				pin_info_cb(), setting_pin_main(), pins_editor_cb()to handle SIMP unblocking code

	Nov 24, 2005 DR: OMAPS00045909 - Shashi Shekar B.S.
	Description: Improve IMEI control mechanism
	Solution : When MMI calls sAT_PLUSCFUN, if an IMEI invalid error is returned,
		we will block on that screen & will not allow the user to browse menus further,
		since the PS will not be booted at all!!!
 
	Nov 17, 2005 DR: OMAPS00050447 - nekkareb
	Description: Even after removing the SIM , Hutch or Airtel network is seen
	Solution : Sim removal event is now being handled and appropriate display shown.
    Nov 15,2005 	DR : OMAPS00057280	-	x0034700
 	Description:	Compilation Errors in Neptune build while integrating  latest MMI Changes
 	Solution:		Included the compilation FLAG "NEPTUNE_BOARD" for un wanted code for Neptune build


	Nov 03, 2005 DR: OMAPS00050595 - xpradipg
	Description: SIMP: If the SIM is blocked (by entering invalid PIN1), the user is 
			    not able to unblock it even after entering the valid PUK1
	Solution : The global flag for SIM Personlaization PUK request was set even
			for the SIM PUK request. This setting is removed. Also the condition
			check has been done first for the global flag and then the rest of the
			checks.
 
	Nov 03, 2005 DR: OMAPS00052032 - xpradipg
	Description : Locosto: SIMP - integration of issues submitted by solDel on 
			     ME Personalization - changes as per the new interfaces
	Solution	:   The return value of sAT_PlusCLCK of AT_EXCT is handled and 
			    a please wait screen is displayed until the response is recieved 
			    
	Sept 24, 2005 REF:  LOCOSTO-ENH-34438, xpradipg
  	Description: Integration changes required with new aci labe
  	Solution: changes to adopt to the new ACI label   

	July 19, 2005 REF: CRR LOCOSTO-ENH-28173 xpradipg
  	Description: To provide MMI Support to enable/disable/change password and 
  				query all the Personalization locks
  	Solution: Integration of the changes for the same provided by the soldel 
  			  team

 	June 16, 2005  REF: CRR 31267  x0021334
	Description: Handset ignore the initializtion of the PIN1/PIN2
	Fix:	Cheking is done to ascertain if PIN1/PIN2 are initialised. If not, appropriate
	       message is displayed to the user.

//  May 31, 2004        REF: CRR 17291  xvilliva
//	Bug:	After power cycle the setting of the used line which have been made 
//			from the BMI is lost.
//	Fix:	The Pin2 which is entered in the editor and sent for verification is 
//			stored in a global variable for re-use in sAT_PlusCLCK().

//  May 13, 2004        REF: CRR 13632  xvilliva
//			The PUK1 screen is not brought up even if user enters wrong Pin1 thrice
//			from Idle screen -"**04*OLD_CHV1*NEW_CHV1*NEW_CHV1#".
//			If the Pin1 fails for 2 times - "Not accepted" screen is displayed.
//			but if the Pin1 fails 3rd consecutive time - "Pin Blocked" screen is displayed 
//			and the user is taken to PUK1 screen.
//  May 13, 2004        REF: CRR 13623  xvilliva  
//			The PUK1 screen can be exited by pressing HangUP or Back key.
//			The PUK1 screen if contains less than 1 character then back key is disabled.
//			Hangup key is disabled permenantly to avoid exiting the screen.


	25/10/00			Original Condat(UK) BMI version.	
	   
 $End

  // Issue Number : SPR#15692 on 25/03/04 by Rashmi.C.N.

*******************************************************************************/



/*******************************************************************************
									      
				Include Files
									      
*******************************************************************************/
#define ENTITY_MFW

/* includes */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#if defined (NEW_FRAME)

#include "typedefs.h"
#include "vsi.h"
#include "pei.h"
#include "custom.h"
#include "gsm.h"

#else

#include "STDDEFS.H"
#include "custom.h"
#include "gsm.h"
#include "vsi.h"

#endif
#include "mfw_sys.h"

#include "prim.h"


#include "mfw_mfw.h"
#include "mfw_win.h"
#include "mfw_kbd.h"
/* SPR#1428 - SH - New Editor changes */
#ifndef NEW_EDITOR
#include "mfw_edt.h"
#endif
#include "mfw_lng.h"
#include "mfw_cm.h"
#include "mfw_icn.h"
#include "mfw_phb.h"
#include "ksd.h"
#include "psa.h"
#include "mfw_ss.h"
#include "mfw_sim.h"
#include "mfw_nm.h"
#include "mfw_sat.h"
#include "mfw_tim.h"
#include "mfw_mnu.h"
#include "mfw_sms.h"

//x0pleela 15 May, 2007 DR: OMAPS00127483
#ifdef FF_PHONE_LOCK
#ifdef FF_MIDI_RINGER  
#include "mfw_midi.h"
#endif //FF_MIDI_RINGER 
#endif /* FF_PHONE_LOCK */

#include "dspl.h"


#include "MmiMmi.h"
#include "MmiDummy.h"
#include "MmiDialogs.h"
#include "MmiLists.h"

/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
#include "ATBCommon.h"
#include "ATBDisplay.h"
#include "ATBEditor.h"
#include "AUIEditor.h"
#include "AUIPinEditor.h"
#else
#include "MmiEditor.h"
#endif

#include "MmiMain.h"
#include "MmiStart.h"
#include "MmiMenu.h"
#include "MmiSoftKeys.h"
#include "MmiIdle.h"
#include "mmiCall.h"
#include "MmiNetwork.h"
#include "MmiSounds.h"
#include "MmiSettings.h"
#include "MmiServices.h"
#include "Mmiicons.h"
#include "MmiDialogs.h"
#include "MmiPins.h"
#include "MmiCPHS.h"
#include "cus_aci.h"
#ifndef NEPTUNE_BOARD
#include "p_sim.h"
#endif
#include "prim.h"
#ifndef PCM_2_FFS
#include "pcm.h"
#endif


#include "mmiColours.h"
#include "mmiSmsIdle.h" //GW SPR#1035 - For smsidle_unset_ready_state(void) definition.
#ifdef SIM_PERS
#include "aci_cmh.h"
#include "cmh.h"
#endif
//#define CLEAR_PIN_EDIT_AREA dspl_Clear(0,30,LCD_X,LCD_Y);


//x0pleela 06 Mar, 2007 ER: OMAPS00122561
#ifdef FF_PHONE_LOCK
#include "usb/usb_api.h"
#include "mfw_mme.h"
//x0pleela 15 May, 2007 DR: OMAPS00127483
#include "MmiSounds.h"
#endif /* FF_PHONE_LOCK */

#ifdef SIM_PERS
//x0pleela 25 Apr, 2006  DR: OMAPS00067919
//Global variable to store the code result of qAT_PlusCPIN() result
extern T_ACI_CPIN_RSLT simp_cpin_code; 
extern UBYTE simp_cpin_flag;
#endif


/* PROTOTYPS */

static int pin_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
static int pin_edt_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
static int pin_edt_kbd_cb (T_MFW_EVENT event, T_MFW_KBD * kc);
static void check_pins (T_MFW_HND win,void * edt_pin);
static void gsm_sec_execute(T_MFW_HND win,void *string);
static void pin_edt_tim_out_cb (T_MFW_EVENT event,T_MFW_TIM * t);
static int pin_mess_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
static void pin_icons(void);
static void clear_edit_array (void * parameter);
static void emerg_pin(void * string);
static int sim_rem_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
static void pin_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
static int gsm_test(T_MFW_HND win,void * edt_pin);
static void pin_editor(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
static void sim_rem_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
static int pin_edt_kbd_long_cb (T_MFW_EVENT event,T_MFW_KBD *  kc);
static void main_call_edit(T_MFW_HND win, USHORT event);
static void main_call_mess(T_MFW_HND win,USHORT event);
static int setting_pin_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
static int set_pin_mess_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
static void sett_pin_mess(T_MFW_HND win,USHORT event);
static void check_set_pins (T_MFW_HND win,void * edt_pin);
static int set_pin_kbd_cb (T_MFW_EVENT event,T_MFW_KBD *  kc);
static void set_pin_editor(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
static int set_pin_win_cb (T_MFW_EVENT event,T_MFW_WIN * win);
static void sett_pin_edit(T_MFW_HND win,USHORT event);
static int gsm_set_test(T_MFW_HND win,void * edt_pin);
static void set_mode_fdn_adn(T_MFW_HND win,void * string);
static void check_plock_to_clock(T_MFW_HND win,USHORT event);
static void check_nlock_to_clock(T_MFW_HND win,USHORT event);
static void check_splock_to_clock(T_MFW_HND win,USHORT event);
static void check_nslock_to_clock(T_MFW_HND win,USHORT event);
static void check_sim_clock(T_MFW_HND win,USHORT event);
static void pin_ch_end_or_abort (T_MFW_HND win);
static void pin_verif_or_check2_end(T_MFW_HND win);
static void pin1_en_dis_verify(T_MFW_HND win);
static int set_pin_edt_win_cb (T_MFW_EVENT event,T_MFW_WIN * win);
static int set_pin_edt_kbd_long_cb (T_MFW_EVENT event,T_MFW_KBD *  kc);
static void gsm_sec_execute_set(T_MFW_HND win,void *string);
void pin2_not_available_screen(void);  /* Warning Correction */
static void not_avail_cb(T_MFW_HND win, UBYTE identifier, UBYTE reason);
static void pins_editor_cb (T_MFW_HND win, USHORT Identifier, SHORT reason);
void pin1_not_enabled_screen(void);  /* Warning Correction */

// June 16, 2005  REF: CRR 31267  x0021334
// Call back function for handling uninitialised PIN1 condition
void pin1_cb_function (T_MFW_HND win, UBYTE identifier, UBYTE reason);

static void pins_editor_cb (T_MFW_HND win, USHORT Identifier, SHORT reason);
/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
void pins_loadEditDefault (T_AUI_EDITOR_DATA *editor_data, USHORT TitleId, USHORT Idenfitier);
#else /* NEW_EDITOR */
void pins_loadEditDefault (T_EDITOR_DATA *editor_data);
#endif /* NEW_EDITOR */
/* SPR#1746 - SH - Add identifier parameter */
void show_confirmation (T_MFW_HND win, USHORT Identifier);
static int show_confirmation_cb(T_MFW_HND win, USHORT identifier, UBYTE reason);

void pin_skClear( void );
void pin_rectClear( MfwRect *win );


#ifdef SIM_PERS
//this global variable is used to track which lock was selected
S16 mmi_simlock_locktype =0xFF;
//	Nov 03, 2005 DR: OMAPS00052032 - xpradip
//	holds the info display handle
static T_MFW_HND info_disp = NULL;
//this global variable is used to track the action to be performed on the selected category
S16 mmi_simlock_lockaction = 0xFF;
static T_ACI_ERR_DESC mmi_simlock_aciErrDesc = 0;
//	Sept 24, 2005 REF:  LOCOSTO-ENH-34438, xpradipg
//	added prototypes require for new compiler 2.54
static void mmi_simlock_reset_fc_value(T_MFW_HND win);
static void mmi_simlock_en_dis_verify(T_MFW_HND win);
#endif

extern T_MFW_SS_RETURN mfw_simlock_enable_lock(U8 *pin, S16 lcktyp);
extern T_MFW_SS_RETURN mfw_simlock_disable_lock(U8 *pin, S16 lcktyp);

#define NUM_OF_PLOCK	 6
// the coordinate of the TxtId 
//moved info text defines to MmiResources.h
#define PIN_ENTRY_MAX	3
#define STAR		0x2a
#define HASH		0x23
#define FIRST_DIGIT	  1
//#define NUM_OF_PLOCK	 6
#define IDENT_GSM_1	 5
#define IDENT_GSM_2	 6
#define TIM_LOCK	 0x01
#define TIM_LOCK_JUMP	 1000
typedef struct
{
  T_MMI_CONTROL    mmi_control;
  T_MFW_HND	   parent_win;
  T_MFW_HND	   pin_win;
  T_MFW_HND	   sim_handle;
#ifdef SIM_PERS
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
//New window handler for the new menu "menuBootupCatList"
  T_MFW_HND	   simp_list_win;
  UBYTE 	   mk_pin[MAX_PIN+1];	    /* Master Unlock Key*/
#endif
  int		   pin_retries; 	/* number of  pin attempts  */
  UBYTE 	   puk_request;
  USHORT		   display_id1;
  USHORT		   display_id2;
  UBYTE 	   gsm_state;		/* status gsm in security   */
  SET_CASE	   set_state;		/* setting state	    */
  UBYTE 	   pin[MAX_DIG+1];	    /* number string pin	*/
  UBYTE 	   puk[MAX_PIN+1];	/* number string puk	    */
  UBYTE 	   new_pin[MAX_PIN+1];	/* store new pin	    */
  UBYTE 	   old_pin[MAX_PIN+1];	/* store old pin	    */
  PIN_CASE	   pin_case;		/* editor state 	    */
  char				edtbuf[MAX_DIG];  
} T_pin;
typedef struct
{
  T_MMI_CONTROL    mmi_control;
  T_MFW_HND	   parent_win;
  T_MFW_HND	   pin_mess_win;
  USHORT		   display_id1;
  USHORT		   display_id2;
  PIN_CASE	   pin_case;
}T_pin_mess;

typedef struct
{
  T_MMI_CONTROL    mmi_control;
  T_MFW_HND	   parent_win;
  T_MFW_HND	   pin_edt_win;
  T_MFW_HND	   kbd_handle;
  T_MFW_HND	   kbd_long_handle;
#ifdef NEW_EDITOR		/* SPR#1428 - SH - New Editor changes */
  T_ED_DATA *	editor;
#else /* NEW_EDITOR */
  T_MFW_HND	   editor_handle;
#endif /* NEW_EDITOR */
  T_MFW_HND	   tim_out_handle;
  UBYTE 	   pin[MAX_PIN+1];	    /* number string pin	*/
  UBYTE 	   puk[MAX_PIN+1];	/* number string puk	    */
  UBYTE 	   new_pin[MAX_PIN+1];	/* store new pin	    */
  UBYTE 	   old_pin[MAX_PIN+1];	/* store old pin	    */
  UBYTE 	   editor_index;
  PIN_CASE	   pin_case_edit;
  UBYTE 	   gsm_state;		/* status gsm in security   */
  UBYTE 	   emergency_call;
  char edtbuf[MAX_DIG];
#ifdef NEW_EDITOR		/* SPR#1428 - SH - New Editor changes */
  T_ED_ATTR editorPinAttr;
#else /* NEW_EDITOR */
  MfwEdtAttr editpinAttr;
#endif /* NEW_EDITOR */
}T_pin_edt;

typedef struct
{
  T_MMI_CONTROL    mmi_control;
  T_MFW_HND	   parent_win;
  T_MFW_HND	   sim_rem_win;
  T_MFW_HND	   sim_handle;
  PIN_CASE	   pin_case;
  USHORT		   display_id1;
} T_sim_rem;

LOCAL T_sim_rem sim_rem_data;

static T_MFW_HND pin_windows;
static T_MFW_HND pin_edit_windows;
static T_MFW_HND pin_editor_window;
static T_MFW_HND pin_mess_windows;
static T_MFW_HND set_pin_windows;
/* static T_MFW_HND sim_rem_handle;   x0039928-Lint warning removal */

//API define for a flag for PIN Emergency Entry
UBYTE pin_emergency_call;
char pin_emerg_call[MIN_PIN];

#ifdef SIM_PERS
UBYTE FCUnlock_flag;
UBYTE perm_blocked;
UBYTE gsim_status;
/*a0393213 warnings removal-sim_unlock_in_prog made to be of type T_MFW_SIMP_CLCK_FLAG*/
EXTERN T_MFW_SIMP_CLCK_FLAG sim_unlock_in_prog; // June 07, 2006    DR: OMAPS00080701   x0021334
#endif
//June 16, 2005  REF: CRR 31267  x0021334
BOOL pin1Flag = FALSE; 

// June 16, 2005  REF: CRR 31267  x0021334
extern BOOL pin2Flag; // This variable will be needed here

//xashmic 21 Sep 2006, OMAPS00095831
//To track the various stages during bootup
T_BOOTUP_STATE BootUpState = BOOTUP_STATE_NONE;

//x0pleela 08 ep, 2006  DR: OMAPS00091250
//Adding the prototype
void mfw_flash_write(char *LogMsg,...);

//x0pleela 06 Mar, 2007 ER: OMAPS00122561
#ifdef FF_PHONE_LOCK
EXTERN T_call call_data; 
static int autoPhLock_menu;
T_MFW_HND	phlock_win_handle;			/* to hold the win handle of phone unlock editor window 	*/
T_MFW_HND	phlock_kbd_handle;			/* to hold the kbd handle of phone unlock editor window 	*/
T_MFW_HND	phlock_alarm_win_handle; 	/* to hold the win handle of alarm window 				*/
T_MFW_HND	phlock_mtc_win_handle;		/* to hold the win handle of MT call window 			*/
T_MFW_HND   phlock_dialog_mtc_win_handle;/* to hold the win handle of MT call dialog window 		*/
int 			phlock_alarm;				/* flag to check whether alarm event has occured or not 	*/ 
//x0pleela 09 Mar, 2007  DR: OMAPS00129014
EXTERN UBYTE phlock_auto;				/* flag to check whether auo phone lock is enabled or not */

//x0pleela 15 May, 2007 DR: OMAPS00127483
#ifdef FF_MMI_AUDIO_PROFILE
extern UBYTE mfwAudPlay;//flag for audio 
#endif

void mmi_phlock_change_pin(T_MFW_HND win,int type,char* oldpsw,char* newpsw);
static void mmi_phlock_en_dis_verify(T_MFW_HND win);

//x0pleela 19 Mar, 2007 ER: OMAPS00122561
EXTERN void mmi_set_usbms_enum( int usb_enum);
EXTERN int mmi_get_usbms_enum(void);
EXTERN void mmi_set_Headset_Reg( int headset_reg);
EXTERN int mmi_get_Headset_Reg(void);
static MfwHnd mmi_phlock_show_info(T_MFW_HND parent, int str1, int str2, T_VOID_FUNC callback);
T_MFW_HND phlock_setting_pin_create (T_MFW_HND parent_window);
static int phlock_setting_pin_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
void phlock_setting_pin_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
static void phlock_sett_pin_mess(T_MFW_HND win,USHORT event);
T_MFW_HND phlock_set_pin_mess_create(T_MFW_HND parent_window);
void phlock_set_pin_mess_destroy  (T_MFW_HND own_window);
static int phlock_set_pin_mess_win_cb (T_MFW_EVENT event, T_MFW_WIN * win);
void phlock_set_pin_messages(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
void phlock_set_pin_info_cb(T_MFW_HND win, USHORT identifier, UBYTE reasons);
static void phlock_sett_pin_edit(T_MFW_HND win, USHORT event);
T_MFW_HND phlock_set_pin_edt_create (T_MFW_HND parent_window);
static int phlock_set_pin_edt_win_cb (T_MFW_EVENT event,T_MFW_WIN * win);
static void phlock_set_pin_editor(T_MFW_HND win, USHORT event, SHORT value, void * parameter);
static int phlock_set_pin_kbd_cb (T_MFW_EVENT event,T_MFW_KBD *  kc);
static int phlock_set_pin_edt_kbd_long_cb (T_MFW_EVENT event,T_MFW_KBD *  kc);
static void phlock_pin_edt_tim_out_cb (T_MFW_EVENT event,T_MFW_TIM * t);
void phlock_setting_pin_destroy  (T_MFW_HND own_window);
void phlock_set_pin_edt_destroy  (T_MFW_HND own_window);
T_MFW_SS_RETURN mfw_phlock_enable_lock(U8 *pin, S16 lcktyp);
T_MFW_SS_RETURN mfw_phlock_disable_lock(U8 *pin, S16 lcktyp);

//x0pleela 29 May, 2007 DR: OMAPS00132483
EXTERN int mfw_get_Phlock_status(void);
EXTERN void mfw_set_Phlock_status( int phlock_status);
EXTERN int mfw_get_Auto_Phlock_status(void);
EXTERN void mfw_set_Auto_Phlock_status( int phlock_status);
#endif /* FF_PHONE_LOCK */

/*******************************************************************************

 $Function:	pin_init 

 $Description:	This is the start-up time initialisation routine.
		call from init routine in the idle
 
 $Returns:		None

 $Arguments:	parent window
 
*******************************************************************************/
void pin_init (T_MFW_HND parent_window)
{
	 pin_create (parent_window);
  BootUpState = BOOTUP_STATE_NONE;//xashmic 21 Sep 2006, OMAPS00095831
}


/*******************************************************************************

 $Function:	pin_exit 

 $Description:	power down in security screen
 $Returns:		None

 $Arguments:	None
 
*******************************************************************************/
void pin_exit (void)
{
 if(pin_mess_windows)
	 pin_mess_destroy(pin_mess_windows);

 if (pin_editor_window)
 {
#ifdef NEW_EDITOR
	AUI_pin_Destroy(pin_editor_window);
#else
	editor_destroy(pin_editor_window);
#endif
	pin_editor_window = NULL;
 } 
 
 if (pin_edit_windows)
	 pin_edt_destroy(pin_edit_windows);

 if(pin_windows)
 {
	TRACE_FUNCTION("pin_destroy 1");
	pin_destroy (pin_windows);

 }
}


/*******************************************************************************

 $Function:	pin_create

 $Description:	Creation of an instance for the PIN dialog (sim activation)

		Type of dialog : SINGLE_DYNAMIC
 $Returns:		Window

 $Arguments:	Parent window
 
*******************************************************************************/
T_MFW_HND pin_create (T_MFW_HND parent_window)
{

  T_MFW_WIN	* win;
  T_pin * data = (T_pin *)ALLOC_MEMORY (sizeof (T_pin));

  data->pin_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)pin_win_cb);

  pin_windows = data->pin_win;
  pin_edit_windows = NULL;
  pin_editor_window = NULL;
  pin_mess_windows = NULL;

  TRACE_FUNCTION("MmiPins:pin_create");

  if (data->pin_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  data->mmi_control.dialog    = (T_DIALOG_FUNC)pin_main;/* dialog main function    */
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_win)->data;
  win->user		      = (void *) data;


  /*
   * Create any other handler
   */

  data->sim_handle = sim_create(data->pin_win,E_SIM_ALL_SERVICES,(MfwCb)sim_event_cb_main);

  /*
   * return window handle
   */

	mfwSetSignallingMethod(1);//mfw focus handling
	winShow(data->pin_win);


  return data->pin_win;
}


/*******************************************************************************

 $Function:	pin_destroy

 $Description:	Destroy the pin dialog.
 $Returns:		None

 $Arguments:	window
 
*******************************************************************************/
void pin_destroy  (T_MFW_HND own_window)
{

  T_pin *      data;
  T_MFW_WIN *	win;

  TRACE_FUNCTION("MmiPins:pin_destroy");

  if (own_window)
  {
    win = ((T_MFW_HDR *)own_window)->data;
    data = (T_pin *)win->user;

	 if(data)
	 {
      /*
       * Exit SIM and Delete SIM Handler
       */
      sim_delete (data->sim_handle);

      /*
       * Delete WIN Handler
       */
      win_delete (data->pin_win);
	  pin_windows = 0;
	  FREE_MEMORY((void *)data,(sizeof(T_pin)));
	 }
  }
}


/*******************************************************************************

 $Function:	pin_win_cb

 $Description:	Callback function for windows
 $Returns:		Status int
 $Arguments:	window handler event, window
 
*******************************************************************************/
static int pin_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
  TRACE_EVENT_P1("pin_win_cb: %d", event);

  if (event EQ MfwWinVisible)
  {
    dspl_ClearAll();
	return 1;
  }
  return 0;
}





/*******************************************************************************

 $Function:	sim_event_cb_main

 $Description:	PURPOSE : SIM event handler for Pins
 $Returns:		Status int
 $Arguments:	window handler event, sim status
 
*******************************************************************************/
int sim_event_cb_main (T_MFW_EVENT event, T_MFW_HND para)
{
/**********************/
// #define NO_ACTION	0  /* Warning Correction */

// BYTE reconf_handling = NO_ACTION;  /* Warning Correction */
// BYTE reconf_defreeze_display = 1;  /* Warning Correction */
/*********************/

	T_MFW_SIM_STATUS * status;
	UBYTE limited;

    T_MFW_HND win = mfw_parent(mfw_header());

#ifdef SIM_PERS
	int status1, max1, curr1;
#endif
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;

	T_pin * pin_data = (T_pin *)win_data->user;

	status = (T_MFW_SIM_STATUS *)para;

    limited = TRUE;			/* initial limited mode     */

  TRACE_EVENT_P3("sim event handler,event:%d, status:%d, proc:%d",event, status->sim_status, status->sim_procedure);
// June 16, 2005  REF: CRR 31267  x0021334
// If PIN1 and PUK1 are uninitialised, post SIM_LOCKED event
    if ((sim_pin_count(MFW_SIM_PIN1) EQ 0) AND (sim_pin_count(MFW_SIM_PUK1) EQ 0))
    {	
    	SEND_EVENT(pin_data->pin_win, SIM_LOCKED, 0, pin_data);
    }
    else // June 16, 2005  REF: CRR 31267  x0021334
    {
 	switch(event)
 	{
		case E_SIM_INSERTED:	/*  there not handled */

		BootUpState = BOOTUP_STATE_COMPLETED;//xashmic 21 Sep 2006, OMAPS00095831
		
		/* 14-Mar-2006, Monika.B.J., x0045876, START (Bug OMAPS00071413) */
#ifdef FF_MMI_SAT_ICON
				    addSatMessage(NULL, 0, 0, NULL, FALSE, SAT_ICON_IDLEMODE_TEXT);

#else
					addSatMessage(NULL);
#endif
// July 11, 2006    DR: OMAPS00084081   x0039928
// Fix: Registers to network on sim reset
		 nm_registration (NM_AUTOMATIC, 0, FALSE);
       		/*OMAPS00115179 - support SIM insertion without powering down - a0393213(R.Prabakar)
       		   If pin_editor_window for the removed SIM("Insert SIM" window or "PIN" entry window) is present 
       		   destroy it when a new SIM is inserted. 
       		   If "PIN" entry window is necessary even for the newly inserted SIM, it 
       		   would be created once again at a different point. */
           		if(pin_editor_window)
      			{
          			AUI_pin_Destroy(pin_editor_window);
            			pin_editor_window=NULL;
      			}
         		smsidle_unset_ready_state ();
			
		/* 14-Mar-2006, Monika.B.J., x0045876, END */
					return 0;		/* (handled in sim_rem dialog, commented out currently */


		//GW-SPR#1035-Added STK Changes
		case E_SIM_RESET:	
	    	TRACE_FUNCTION("E_SIM_RESET");
		/*NM, 110702
			the MM-entity initated the de-registration already (MMI dont have to do it); 
			after this event we should avoid any cases to access the SIM
			(e.g. reading phonebook, reading sms....)
			
			- how to do it ???
			->  unset the "sms_initialised" flag to FALSE

			- when does it set back to TRUE ???
			-> the flag will be set after the event "E_SMS_READY"
		*/	
			smsidle_unset_ready_state ();
			info_screen(0, TxtSimNot, TxtReady, NULL); 
		/*NM, 110702 END*/
	    return 0;		
	    

		case E_SIM_STATUS:
	  	/*
	   	* check whether decoded message is available
	   	*/
		if( para EQ (T_MFW_SIM_STATUS *)NULL )
		   return MFW_RES_ILL_HND;

		status = (T_MFW_SIM_STATUS *)para;

 TRACE_FUNCTION_P1("sim_status: %d", status->sim_status);

/********************************/
#ifdef SIM_PERS		

			  //x0pleela 18 Oct, 2006 DR: OMAPS00099660
			  //Added the following code (MFW_MEPD_INVALID)inside the SIM_PERS flag
			  //x0pleela 08 Sep, 2006  DR: OMAPS00091250
			  //Write No MEPD, NO SIM string into a file
			  if(  status->sim_procedure == MFW_SIM_ACTIVATION )
			  {
			  	if(status->sim_status ==  MFW_MEPD_INVALID)
					mfw_flash_write("No MEPD");
				if(status->sim_status == MFW_SIM_NO_SIM_CARD)
					mfw_flash_write("No SIM");
			  }
					

				//x0pleela 29 Aug, 2006 DR: OMAPS00091250
				//Added this check so that MMI doesn't hang at boot up as 
				//MEPD data is not present
				if( ( status->sim_procedure == MFW_SIM_ACTIVATION )AND 
					( ( status->sim_status !=  MFW_MEPD_INVALID) OR
					(status->sim_status != MFW_SIM_NO_SIM_CARD) ) )
				{
				
						status1 =mfw_simlock_check_status(0,&max1, &curr1);
						if(status1== MFW_SIM_PERM_BLOCKED)
						{
							perm_blocked = 1;
						 	status->sim_status=MFW_SIM_PUK_REQ;
						}
				}
				
#endif
			BootUpState = BOOTUP_STATE_INPROGRESS;//xashmic 21 Sep 2006, OMAPS00095831

		 switch (status->sim_procedure)
		 {
		/*
		 * Initial activation of the SIM card
		 */
			case MFW_SIM_ACTIVATION:
		  /*
		   * check the result of activation
		   */
			  switch (status->sim_status)
			  {
				  //x0pleela 18 Oct, 2006 DR: OMAPS00099660
				  //Added the following code (MFW_MEPD_INVALID)inside the SIM_PERS flag
#ifdef SIM_PERS			  
			  //x0pleela 29 aug, 2006  DR: OMAPS00091250
			  	//Send event No MEPD data
			  	case MFW_MEPD_INVALID:
					//limited = TRUE;
					TRACE_FUNCTION("sim_event_cb_main:no MEPD data");
					SEND_EVENT(pin_data->pin_win,NO_MEPD, 0, pin_data);
					break;
#endif					
			/*
			 * PIN 1 must be entered
			 */
					case MFW_SIM_PIN_REQ:
						if(status->sim_pin_retries < PIN_ENTRY_MAX)
						{
							TRACE_FUNCTION("sim_event_cb_main:PIN1 req-retr");
							pin_data->pin_retries = status->sim_pin_retries;/* number of retries */
							SEND_EVENT(pin_data->pin_win,PIN1_REQ_ATT,0,pin_data);
						}
						else
						{

/********************************/

							TRACE_FUNCTION("sim_event_cb_main:PIN1 req");
							SEND_EVENT(pin_data->pin_win,PIN1_REQ,0,pin_data);
						}
						break;

			/*
			 * SIM card is blocked, PUK 1 is needed
			 */
					case MFW_SIM_PUK_REQ:
					{
#ifdef SIM_PERS
						int smlk_status, max, curr; //x0pleela 19 Apr, 2006 DR:OMAPS00067912   changed the name from stastus to smlk_status
#endif
							TRACE_FUNCTION("sim_event_cb_main:PUK1 req");
#ifdef SIM_PERS
						//x0pleela 19 Apr, 2006 DR:OMAPS00067912   
						//changed the name from stastus to smlk_status
						smlk_status =mfw_simlock_check_status(0,&max, &curr);
						if( (smlk_status== MFW_SIM_BLOCKED) OR (smlk_status == MFW_SIM_NOT_BLOCKED) )
						{
							TRACE_EVENT("BMI: MFW_SIM_BLOCKED");
							perm_blocked = 0;
								TRACE_EVENT("BMI: MFW_SIM_PUK1");
							//x0pleela 26 Sep, 2006 DR: OMAPS00096565
							//Adding a check for C_KEY_REQ. If set, display SIMP menu
							//Else prompt the user for PUK entry
							if( C_KEY_REQ )
							{
								//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
								//check for Master Unlock option enabled. 
								//If so, then display the menu with options Unblock ME and Master Unlock
								if( simlock_get_masterkey_status())
						  		{
							  		pin_data->simp_list_win = mmi_simlock_category_menus(win);
							  	}
						  	}
							else
#endif
								SEND_EVENT(pin_data->pin_win,PUK1_REQ_ACT_INFO,0,pin_data);

#ifdef SIM_PERS
						}
						//x0pleela 19 Apr, 2006 DR:OMAPS00067912   
						//changed the name from stastus to smlk_status
						else if (smlk_status == MFW_SIM_PERM_BLOCKED)
						{
							perm_blocked =1;
							SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
						}
#endif
         				 }
					break;

			/*
			 * no PIN is needed
			 */
					case MFW_SIM_NO_PIN:
						
						BootUpState = BOOTUP_STATE_COMPLETED;//xashmic 21 Sep 2006, OMAPS00095831

						limited = FALSE;
						TRACE_FUNCTION("sim_event_cb_main:no Pin");
						mmi_cphs_refresh();
						SEND_EVENT(pin_data->pin_win,PIN_OK, 0, NULL);//back to idle
						break;

			/*
			 * SIM card is broken
			 */
					case MFW_SIM_INVALID_CARD:
						TRACE_FUNCTION("sim_event_cb_main: invalid card");
						SEND_EVENT(pin_data->pin_win,INVALID_CARD, 0, pin_data);
						break;

			/*
			 * No SIM card is inserted
			 */
					case MFW_SIM_NO_SIM_CARD:
						
						TRACE_FUNCTION("sim_event_cb_main: no SIM Card");
						SEND_EVENT(pin_data->pin_win,NO_SIM_CARD, 0, pin_data);
						break;

// Nov 24, 2005, a0876501, DR: OMAPS00045909
					case MFW_IMEI_NOT_VALID:
						limited = FALSE;
						TRACE_FUNCTION("sim_event_cb_main: IMEI is not valid");
						SEND_EVENT(pin_data->pin_win,INVALID_IMEI, 0, pin_data);
						break;

#ifdef SIM_PERS 

					case MFW_SIM_PLOCK_REQ:
						TRACE_FUNCTION("sim_event_cb_main: MFW_SIM_PLOCK_REQ");
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//check for Master Unlock option enabled. 
						//If so, then display the menu with options SIM unlock and Master Unlock
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_PLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						    SEND_EVENT(pin_data->pin_win,INPUT_SIM_PIN_REQ, 0, pin_data);
						break;
						
					case MFW_SIM_NLOCK_REQ:
						TRACE_FUNCTION("sim_event_cb_main: MFW_SIM_NLOCK_REQ");
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//check for Master Unlock option enabled. 
						//If so, then display the menu with options Network unlock and Master Unlock					  
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_NLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						    SEND_EVENT(pin_data->pin_win,INPUT_NLOCK_PIN_REQ, 0, pin_data);
						break;
						
					case MFW_SIM_NSLOCK_REQ:
						TRACE_FUNCTION("sim_event_cb_main: MFW_SIM_NSLOCK_REQ");
  						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//check for Master Unlock option enabled. 
						//If so, then display the menu with options Network subset unlock and Master Unlock
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_NSLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						    SEND_EVENT(pin_data->pin_win,INPUT_NSLOCK_PIN_REQ, 0, pin_data);
						break;
						
					case MFW_SIM_SPLOCK_REQ:
						TRACE_FUNCTION("sim_event_cb_main: MFW_SIM_SPLOCK_REQ");
  						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//check for Master Unlock option enabled. 
						//If so, then display the menu with options Service Provider unlock and Master Unlock					  
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_SPLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
							SEND_EVENT(pin_data->pin_win,INPUT_SPLOCK_PIN_REQ, 0, pin_data);
						break;
						
					case MFW_SIM_CLOCK_REQ:
						TRACE_FUNCTION("sim_event_cb_main: MFW_SIM_CLOCK_REQ");
  						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//check for Master Unlock option enabled. 
						//If so, then display the menu with options Corporate unlock and Master Unlock					  
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_CLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
    						    SEND_EVENT(pin_data->pin_win,INPUT_CLOCK_PIN_REQ, 0, pin_data);
						break;

					//x0pleela 25 Sep, 2006 ER: OMAPS00095524
					//Request unlocking password of "Blocked Network" category
					case MFW_SIM_PBLOCK_REQ:
						TRACE_FUNCTION("sim_event_cb_main: MFW_SIM_PBLOCK_REQ");
						//check for Master Unlock option enabled. 
						//If so, then display the menu with options Network unlock and Master Unlock					  
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_PBLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						    SEND_EVENT(pin_data->pin_win,INPUT_PBLOCK_PIN_REQ, 0, pin_data);
						break;
#endif
					default:
						return 0;
			  }
		  /*
		   * start limited or full service */

			  if (limited)
			  {
			/*
			 * limited shall be the requested service
			 * if no service is reached, the limited
			 * service is requested*/
			 	TRACE_FUNCTION("DEBUG");

					if (nm_reg_status() EQ NOT_PRESENT_8BIT
						AND
						status->sim_procedure EQ MFW_SIM_ACTIVATION)
						{
							TRACE_FUNCTION("registration in limited mode ");
							nm_registration (NM_AUTOMATIC, 0, TRUE);
						}
			  }
			break;
			case MFW_SIM_VERIFY:
		  /*
		   * check the result of verify
		   */
			  switch (status->sim_status)
			  {
			/*
			 * PIN 1 must be entered
			 */
					case MFW_SIM_PIN_REQ:
					if(status->sim_pin_retries < PIN_ENTRY_MAX)
					{
							TRACE_FUNCTION("sim_event_cb_main:Ver:PIN1 req-retr");
							pin_data->pin_retries = status->sim_pin_retries;
							SEND_EVENT(pin_data->pin_win,PIN1_REQ_ATT,0,pin_data);
					}
					else
					{
							TRACE_FUNCTION("SimEventPins:V:PIN1 req");
							SEND_EVENT(pin_data->pin_win,PIN1_REQ,0,pin_data);
					}
					break;
			/*
			 * SIM card is blocked, PUK 1 is needed
			 */
					case MFW_SIM_PUK_REQ:
						TRACE_FUNCTION("SimEventPins:V:PUK1 req");
						SEND_EVENT(pin_data->pin_win,PUK1_REQ_VER_INFO,0,pin_data);
						break;

			/*
			 * PIN entering successfull
			 */
					case MFW_SIM_NO_PIN:
						TRACE_FUNCTION("sim_event_cb_main:PIN ok without sim unlock");
						mmi_cphs_refresh();
						pin_data->pin_case = PIN_OK_INFO;
						if (pin_data->set_state == PIN2_CHECK)
						{
							set_mode_fdn_adn(win,pin_data);
						}
						SEND_EVENT(pin_data->pin_win,PIN_OK_INFO,0,pin_data);
						break;
			/*
			 * SIM card is broken
			 */
					case MFW_SIM_INVALID_CARD:
						TRACE_FUNCTION("sim_event_cb_main: invalid card");
						SEND_EVENT(pin_data->pin_win,INVALID_CARD, 0, pin_data);
						break;

			/*
			 * No SIM card is inserted
			 */
					case MFW_SIM_NO_SIM_CARD:
						TRACE_FUNCTION("sim_event_cb_main: no SIM Card");
						SEND_EVENT(pin_data->pin_win,NO_SIM_CARD, 0, pin_data);
						break;
					default:
						return 0;
			  }
			break;
			/*
			 * response to PUK entering
			 */
			case MFW_SIM_UNBLOCK:
			  switch (status->sim_status)
			  {
				case MFW_SIM_PUK_REQ:
					TRACE_FUNCTION("sim_event_cb_main:unblock failure");
					SEND_EVENT(pin_data->pin_win,PUK1_UNBL_FAIL_INFO,0,pin_data);
					break;
				case MFW_SIM_SUCCESS:
					TRACE_FUNCTION("sim_event_cb_main:unblock success");
					mmi_cphs_refresh();
					SEND_EVENT(pin_data->pin_win,PUK1_UNBL_SUCC,0,pin_data);
					break;
				case MFW_SIM_FAILURE:
					TRACE_FUNCTION("sim_event_cb_main:unblock fatal error");
					SEND_EVENT(pin_data->pin_win,PUK1_UNBL_FATAL_ERROR,0,pin_data);
					break;				
				case MFW_SIM_INVALID_CARD:
					TRACE_FUNCTION("sim_event_cb_main:unblock failed, no more retries");
					SEND_EVENT(pin_data->pin_win,INVALID_CARD,0,pin_data);
					break;
				default:
					return 0;
			  }
			break;

			case MFW_SIM_REMOVED:/*  Handle the removal of SIM card */
                            /* OMAPS00050447: a0393130, handle removal of sim card */
                            switch (status->sim_status)
                            {
                                 case MFW_SIM_NO_SIM_CARD: 
                                      TRACE_FUNCTION("sim_event_cb_main: SIM Card removed");
						/*OMAPS00115179 - support SIM insertion without powering down - a0393213
						    SMS state should be unset immediately after removing the SIM card. This ensures
						    icons/display related to messages are NOT shown in the idle screen after the removal of SIM card*/						
					       smsidle_unset_ready_state ();									  
                                       SEND_EVENT(idle_get_window(),NETWORK_NO_SERVICE, 0, 0);
                                       break;
					
                                 default:
                                       return 0;
                            }
			 break;
			      /* OMAPS00050447: a0393130, handle removal of sim card */
			  
			default:
				return 0;
		 }

	return 1;
	#ifdef BMI_TEST_MC_SIM_EVENT
	break;
	case BMI_TEST_MC_SIM_EVENT:
	{
		T_MFW_READ_CALLBACK* sim_read_data;

		sim_read_data = (T_MFW_READ_CALLBACK*)para;

		TRACE_EVENT_P3("SIM READ Error: %d, %x%x", sim_read_data->error_code,
			sim_read_data->read_buffer[0], sim_read_data->read_buffer[1]);
	}
	break;
	#endif
  	}
    } // June 16, 2005  REF: CRR 31267  x0021334
    
    /* x0045876, 14-Aug-2006 (WR - missing return statement at end of non-void function ) */
    return 0;
}
#ifdef SIM_PERS
/*******************************************************************************

 $Function:    	simp_busy_cb

 $Description:   This function checks for the ACI CME error and display menu for unlocking
 			  categories or unblocking ME

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
void simp_busy_cb(T_MFW_HND win, USHORT identifier, UBYTE reasons)
{
  T_MFW_WIN   * win_data = ((T_MFW_HDR *) win)->data;

  T_pin * pin_data = (T_pin *)win_data->user;//pin main data
  
    //x0pleela 25 Sep, 2006 ER: OMAPS00095524	
    //check for CME class and handle all CME errors
  if( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Cme) 
  {
  switch(aciErrDesc & 0x0000FFFF)
  {
    case CME_ERR_NetworkPersPinReq:
      TRACE_EVENT("CME_ERR_NetworkPersPinReq");
      if( simlock_get_masterkey_status())
      {
        mmi_simlock_locktype = MFW_SIM_NLOCK;
        pin_data->simp_list_win = mmi_simlock_category_menus(win);
      }
      else
        SEND_EVENT(pin_data->pin_win,INPUT_NLOCK_PIN_REQ,0,pin_data);
  break;
  
    case CME_ERR_NetworkSubsetPersPinReq:
      TRACE_EVENT("CME_ERR_NetworkSubsetPersPinReq");
      if( simlock_get_masterkey_status())
      {
        mmi_simlock_locktype = MFW_SIM_NSLOCK;
        pin_data->simp_list_win = mmi_simlock_category_menus(win);
      }
      else
        SEND_EVENT(pin_data->pin_win,INPUT_NSLOCK_PIN_REQ,0,pin_data);
    break;
    
    case CME_ERR_ProviderPersPinReq:
      TRACE_EVENT("CME_ERR_ProviderPersPinReq");
      if( simlock_get_masterkey_status())
      {
        mmi_simlock_locktype = MFW_SIM_SPLOCK;
        pin_data->simp_list_win = mmi_simlock_category_menus(win);
      }
      else
        SEND_EVENT(pin_data->pin_win,INPUT_SPLOCK_PIN_REQ,0,pin_data);
    break;
    
    case CME_ERR_CorporatePersPinReq:
      TRACE_EVENT("CME_ERR_CorporatePersPinReq");
      if( simlock_get_masterkey_status())
      {
        mmi_simlock_locktype = MFW_SIM_CLOCK;
        pin_data->simp_list_win = mmi_simlock_category_menus(win);
      }
      else
        SEND_EVENT(pin_data->pin_win,INPUT_CLOCK_PIN_REQ,0,pin_data);
    break;
    
    case CME_ERR_PhSimPinReq:
      TRACE_EVENT("CME_ERR_PhSimPinReq");
      if( simlock_get_masterkey_status())
      {
        mmi_simlock_locktype = MFW_SIM_PLOCK;
        pin_data->simp_list_win = mmi_simlock_category_menus(win);
      }
      else
        SEND_EVENT(pin_data->pin_win,INPUT_SIM_PIN_REQ,0,pin_data);
    break;
    
    case CME_ERR_PhoneFail:
    case CME_ERR_NetworkPersPukReq:
    case CME_ERR_NetworkSubsetPersPukReq:
    case CME_ERR_ProviderPersPukReq:
    case CME_ERR_CorporatePersPukReq:
    {
      int status,curr_fail_reset, curr_succ_reset;
      TRACE_EVENT("PUK Req");
      status = mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
      
		if( status == MFW_SIM_BLOCKED)
      {
        C_KEY_REQ = 1;
        if( simlock_get_masterkey_status())
        {
          pin_data->simp_list_win = mmi_simlock_category_menus(win);
        }
        else
          SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
      }
      else if (status == MFW_SIM_PERM_BLOCKED)
      {
        perm_blocked =1;
        SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
      }	
    }
    break;	
    
    case CME_ERR_WrongPasswd:
      TRACE_EVENT("CME_ERR_WrongPasswd");
      SEND_EVENT(pin_data->pin_win,identifier,0,pin_data);
    break;
    
    default:
      TRACE_EVENT("Undefined error");
  }
}

    //x0pleela 25 Sep, 2006 ER: OMAPS00095524	
    //check for Ext class and handle all Extension errors
	else if( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext) 
	{
		switch(aciErrDesc & 0x0000FFFF)
		{
			//x0pleela 25 Sep, 2006 ER: OMAPS00095524
			//Request for Blocked Network Password 
			case EXT_ERR_BlockedNetworkPersPinReq:
				TRACE_EVENT("CME_ERR_NetworkPersPinReq");
				if( simlock_get_masterkey_status())
				{
					mmi_simlock_locktype = MFW_SIM_PBLOCK;
					pin_data->simp_list_win = mmi_simlock_category_menus(win);
				}
				else
					SEND_EVENT(pin_data->pin_win,INPUT_PBLOCK_PIN_REQ,0,pin_data);
			break;

			//x0pleela 25 Sep, 2006 ER: OMAPS00095524
			//Request for Blocked Network Unblock code 
			case EXT_ERR_BlockedNetworkPersPukReq:
			{
				int status,curr_fail_reset, curr_succ_reset;
				TRACE_EVENT("PUK Req");

				status = mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);

				if( status==MFW_SIM_BLOCKED)
				{
					C_KEY_REQ = 1;
					if( simlock_get_masterkey_status())
					{
						pin_data->simp_list_win = mmi_simlock_category_menus(win);
					}
					else
						SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
				}
				else if (status == MFW_SIM_PERM_BLOCKED)
				{
					perm_blocked =1;
					SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
				}	
			}
			break;	

			default:
				break;
		}
	}
  
}

#endif

/*******************************************************************************

 $Function:	pin_main

 $Description:	PIN MAIN Dialog Handling function
 $Returns:		void
 $Arguments:	window, window handler event, value, parameters
 
*******************************************************************************/
static void pin_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user;//pin main data
// 	T_pin_mess * mess_data = (T_pin_mess *) parameter;//pin message data  /* Warning Correction */
//	T_pin_edt * edt_data = (T_pin_edt *) parameter;//pin editor data  /* Warning Correction */

	// June 16, 2005  REF: CRR 31267  x0021334
	// Added the following two variables
	static int pin1_info_count = 0; 
	T_DISPLAY_DATA display_info; 
	
#ifdef NEW_EDITOR
	T_AUI_EDITOR_DATA editor_data;	/* SPR#1428 - SH - New Editor data */
#else
	T_EDITOR_DATA	editor_data;
#endif

	TRACE_EVENT_P1("MmiPins:pin_main: %d", event);

	 switch(event)
	 {
#ifdef SIM_PERS
		//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		//This event displays a dialog "Busy" for the user if timer is enabled and 
		//ACI returns Busy error when user had entered wrong unlocking password
		case SIM_LOCK_BUSY_BOOTUP:
			mfw_simlock_set_busy_state(FALSE);
			dlg_initDisplayData_TextId(&display_info,  NULL, NULL, TxtBusy, TxtNull, COLOUR_STATUS);
			dlg_initDisplayData_events(&display_info, (T_VOID_FUNC)simp_busy_cb, THREE_SECS, KEY_LEFT | KEY_RIGHT);
			info_dialog (pin_data->pin_win, &display_info);
			break;
#endif
	 
		// June 16, 2005  REF: CRR 31267  x0021334
		// This case is added to handle PIN1 and PUK1 EQ 0 condition
	 	 case SIM_LOCKED:
		 if(pin1_info_count EQ 0) // To avoid getting the sim blocked dialog during emergency call set up
		 {
			pin1Flag = TRUE; // set this flag to TRUE to indicate that PIN1 and PUK1 are 0
			// Display info dialog that the sim is blocked for 3 seconds, after which call back function is called.
			dlg_initDisplayData_TextId(&display_info,  NULL, NULL, TxtSimBlocked, TxtDealer, COLOUR_STATUS);
			dlg_initDisplayData_events(&display_info, (T_VOID_FUNC)pin1_cb_function, THREE_SECS, KEY_LEFT | KEY_RIGHT);
			info_dialog (pin_data->pin_win, &display_info);
			pin1_info_count++;
		 }
		 else // post SIM_LOCKED_EMR_EDITOR event to create the editor for entering emergency numbers
		 {
			SEND_EVENT(pin_data->pin_win, SIM_LOCKED_EMR_EDITOR, 0, 0);
		 }
		 break;

		 // June 16, 2005  REF: CRR 31267  x0021334
		// This case is added to handle response from call back function 'pin1_cb_function'
		 case SIM_LOCKED_EMR_EDITOR:
		 memset(pin_data->edtbuf,'\0',sizeof(pin_data->edtbuf));
		 pins_loadEditDefault (&editor_data, TxtSimBlocked, SIM_LOCKED_EMR_EDITOR);
		 AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, (UBYTE *)pin_data->edtbuf, MAX_DIG);
		 pin_editor_window = AUI_pin_Start(win, &editor_data); // start the editor
		 break;

		  case PIN1_STATUS:		    //Text "Pin disabled" or "enabled"
		  case PIN1_REQ_ATT:		    //info screen "xx attempts "
		  case PUK1_REQ_ACT_INFO:	    //info screen "SIM blocked "
		  
		  case GSM_FAIL:		    // gsm not allowed
		  case NEW_PIN_FAIL:		    // new pin failed
		  case PUK1_REQ_VER_INFO:	    // Text "Pin blocked "
		  case PUK1_UNBL_FAIL_INFO:	    // unblock error - new puk requ
		  case PUK1_UNBL_FATAL_ERROR:
		  
		 
		  case SIM_UNLOCK_OK:		    //Text "Unlock ok "
		  case SIM_LOCK_ERR:
#ifdef SIM_PERS
        case SIM_LOCK_PERS_CHK_OK:
		    case SMLK_SHOW_FC_FAIL:
		    case SMLK_SHOW_FC_SUCC:			
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		    case SMLK_SHOW_MK_FAIL:		//wrong master unlock key
		    case SMLK_SHOW_MK_SUCC:		//correct master unlock key
		    case SIM_LOCK_BUSY_UNBLOCK: //wrong unblock code
#endif
				   main_call_mess(win,event);
				   break; 

			case PUK1_REQ:			  //Text "Enter Puk "
#ifdef SIM_PERS
    case INPUT_SIM_PIN_REQ:
		case INPUT_NLOCK_PIN_REQ:
		case INPUT_NSLOCK_PIN_REQ:
		case INPUT_SPLOCK_PIN_REQ:
		case INPUT_CLOCK_PIN_REQ:
		case PERM_BLK:
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		case INPUT_MASTER_KEY_REQ: 		//Master Unlock Key request
		case INPUT_PBLOCK_PIN_REQ:		//x0pleela 25 Sep, 2006 ER: OMAPS00095524
#endif
				//clear the editor-buffer
				memset(pin_data->edtbuf,'\0',sizeof(pin_data->edtbuf));

			/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
#ifdef SIM_PERS
		switch(event)
				{
				case PERM_BLK:
					pins_loadEditDefault (&editor_data, TxtPhoneBlocked, PERM_BLK);
					break;

				case PUK1_REQ:	
				if( C_KEY_REQ )
					pins_loadEditDefault (&editor_data, TxtUnblockCode, PUK1_REQ);
				else					
					pins_loadEditDefault (&editor_data, TxtEnterPuk1, PUK1_REQ);
					break;
				
				case INPUT_NLOCK_PIN_REQ:
					pins_loadEditDefault (&editor_data, TxtEnterNLock, INPUT_NLOCK_PIN_REQ);
					break;
					
				case INPUT_NSLOCK_PIN_REQ:
					pins_loadEditDefault (&editor_data, TxtEnterNsLock, INPUT_NSLOCK_PIN_REQ);
					break;
					
				case INPUT_SPLOCK_PIN_REQ:
					pins_loadEditDefault (&editor_data, TxtEnterSpLock, INPUT_SPLOCK_PIN_REQ);
					break;
					
				case INPUT_CLOCK_PIN_REQ:
					pins_loadEditDefault (&editor_data, TxtEnterCLock, INPUT_CLOCK_PIN_REQ);
					break;

				case INPUT_SIM_PIN_REQ:
					pins_loadEditDefault (&editor_data, TxtEnterPsLock, INPUT_SIM_PIN_REQ);
					break;

				//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
				case INPUT_MASTER_KEY_REQ:
					pins_loadEditDefault (&editor_data, TxtMasterUnlock, INPUT_MASTER_KEY_REQ);
					break;					
					
				//x0pleela 25 Sep, 2006 ER: OMAPS00095524	
				case INPUT_PBLOCK_PIN_REQ:
					pins_loadEditDefault (&editor_data, TxtEnterPbLock, INPUT_PBLOCK_PIN_REQ);
					break;					
					
				}
				TRACE_FUNCTION_P1("sim_status: %d", gsim_status);
#else
			        pins_loadEditDefault (&editor_data, TxtEnterPuk1, PUK1_REQ);
#endif
				//x0pleela 05 Jul, 2006  DR: OMAPS00084642
				//Changed the size of simlock password enty from MAX_DIG to MAX_PIN+1
				AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, (UBYTE *)pin_data->edtbuf, MAX_PIN+1);
				pin_editor_window = AUI_pin_Start(win, &editor_data);
#else /*NEW_EDITOR */
				pins_loadEditDefault (&editor_data);

				editor_data.editor_attr.text	= pin_data->edtbuf;  /* buffer to be edited */
				editor_data.editor_attr.size	= MAX_PIN + 1;	 /* limit to 8 digits */
				editor_data.LeftSoftKey 		= TxtSoftOK;	    
				editor_data.RightSoftKey	= TxtDelete;
				editor_data.TextId			= TxtEnterPuk1;
				editor_data.Identifier		= PUK1_REQ;  
				editor_data.min_enter		= 4;
				editor_data.hide			= TRUE;
#ifdef SIM_PERS
		switch(event)
				{
				case PERM_BLK:
					editor_data.TextId	= TxtPhoneBlocked;
					editor_data.Identifier			= PERM_BLK;  
					break;

				case PUK1_REQ:
				if( C_KEY_REQ )
					editor_data.TextId	= TxtUnblockCode;
				else
					editor_data.TextId	= TxtEnterPuk1;
					editor_data.Identifier = PUK1_REQ;  
					break;

				case INPUT_NLOCK_PIN_REQ:
					editor_data.TextId	=TxtEnterNLock;
					editor_data.Identifier			= INPUT_NLOCK_PIN_REQ;  
					break;
					
				case INPUT_NSLOCK_PIN_REQ:
					editor_data.TextId	=TxtEnterNsLock;
					editor_data.Identifier			= INPUT_NSLOCK_PIN_REQ;  
					break;
					
				case INPUT_SPLOCK_PIN_REQ:
					editor_data.TextId	=TxtEnterSpLock;
					editor_data.Identifier			= INPUT_SPLOCK_PIN_REQ;  
					break;
					
				case INPUT_CLOCK_PIN_REQ:
					editor_data.TextId	=TxtEnterCLock;
					editor_data.Identifier			= INPUT_CLOCK_PIN_REQ;  
					break;

				case INPUT_SIM_PIN_REQ:
					editor_data.TextId	=TxtEnterPsLock;
					editor_data.Identifier			= INPUT_SIM_PIN_REQ;  
					break;

				//x0pleela 20 july, 2006 ER: OMAPS00087586, OMAPS00087587
				case INPUT_MASTER_KEY_REQ:
					editor_data.TextId	=TxtMasterUnlock;
					editor_data.Identifier			= INPUT_MASTER_KEY_REQ;  
					break;

				//x0pleela 25 Sep, 2006 ER: OMAPS00095524
				case INPUT_PBLOCK_PIN_REQ:
					editor_data.TextId	=TxtEnterPbLock;
					editor_data.Identifier			= INPUT_PBLOCK_PIN_REQ;  
					break;					
				}
#endif		
				/* create the dialog handler */
				pin_editor_window = editor_start(win, &editor_data);  /* start the editor */
#endif	/*NEW_EDITOR */
			break;	

			case INPUT_NEW_PIN:
				//clear the editor-buffer
				memset(pin_data->edtbuf,'\0',sizeof(pin_data->edtbuf));

			/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				pins_loadEditDefault (&editor_data, TxtEnterNewPin, INPUT_NEW_PIN);
				AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, (UBYTE *)pin_data->edtbuf, MAX_PIN+1);
				pin_editor_window = AUI_pin_Start(win, &editor_data);
#else /*NEW_EDITOR */
				pins_loadEditDefault (&editor_data);

				editor_data.editor_attr.text	= pin_data->edtbuf;  /* buffer to be edited */
				editor_data.editor_attr.size	= MAX_PIN + 1;	 /* limit to 8 digits */
				editor_data.LeftSoftKey 		= TxtSoftOK;	    
				editor_data.RightSoftKey		= TxtDelete;
				editor_data.TextId				= TxtEnterNewPin;
				editor_data.Identifier			= INPUT_NEW_PIN;  
				editor_data.min_enter		    = 4;
				editor_data.hide			    = TRUE;

				/* create the dialog handler */
				pin_editor_window = editor_start(win, &editor_data);  /* start the editor */ 
#endif /*NEW_EDITOR */
			break;			

			case INPUT_NEW_PIN_AGAIN:
				//clear the editor-buffer
				memset(pin_data->edtbuf,'\0',sizeof(pin_data->edtbuf));
				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				pins_loadEditDefault (&editor_data, TxtConfPin, INPUT_NEW_PIN_AGAIN);

				AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, (UBYTE *)pin_data->edtbuf, MAX_PIN+1);
				pin_editor_window = AUI_pin_Start(win, &editor_data);
#else /*NEW_EDITOR */
				pins_loadEditDefault (&editor_data);
				
				editor_data.editor_attr.text	= pin_data->edtbuf;  /* buffer to be edited */
				editor_data.editor_attr.size	= MAX_PIN + 1;	 /* limit to 8 digits */
				editor_data.LeftSoftKey 		= TxtSoftOK;	    
				editor_data.RightSoftKey		= TxtDelete;
				editor_data.TextId				= TxtConfPin;
				editor_data.Identifier			= INPUT_NEW_PIN_AGAIN;	
				editor_data.min_enter		    = 4;
				editor_data.hide			    = TRUE;

				/* create the dialog handler */
				pin_editor_window = editor_start(win, &editor_data);  /* start the editor */ 
#endif /* NEW_EDITOR */
				break;
				
		  case PIN1_REQ:		    //Text "Enter Pin "
				TRACE_FUNCTION("PIN1_REQ");
				//clear the editor-buffer
				memset(pin_data->edtbuf,'\0',sizeof(pin_data->edtbuf));
				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				pins_loadEditDefault (&editor_data, TxtEnterPin1, PIN1_REQ);

				AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, (UBYTE *)pin_data->edtbuf, MAX_DIG);
				pin_editor_window = AUI_pin_Start(win, &editor_data);
#else /*NEW_EDITOR */
				pins_loadEditDefault (&editor_data);
				
				editor_data.editor_attr.text	= pin_data->edtbuf;  /* buffer to be edited */
				editor_data.editor_attr.size	= MAX_PIN + 1;	 /* limit to 8 digits */
				editor_data.LeftSoftKey 		= TxtSoftOK;	    
				editor_data.RightSoftKey		= TxtDelete;
				editor_data.TextId				= TxtEnterPin1;
				editor_data.Identifier			= PIN1_REQ;  
				editor_data.min_enter		    = 4;
				editor_data.hide			    = TRUE;

				/* create the dialog handler */ 
				pin_editor_window = editor_start(win, &editor_data);  /* start the editor */ 
#endif /* NEW_EDITOR */
			break;

		  case NO_SIM_CARD:		    //Text "No Sim Card "
		  case INVALID_CARD:		    //Text "Invalid SIM card "
// Nov 24, 2005, a0876501, DR: OMAPS00045909
		  case INVALID_IMEI:		    //Text "Invalid IMEI "
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS		  
  		  case NO_MEPD: //x0pleela 30 Aug, 2006 DR: OMAPS00091250
#endif

		  		TRACE_EVENT("NO_SIM OR INVALID_SIM OR INVALID IMEI");

// May 15, 2006 DR: OMAPS00077825 - x0039928
// Fix : TTY is initialized.
#ifdef MMI_TTY_ENABLED
				call_tty_init();
#endif

				/* API - Created the one call to generate the editor as there were two duplicate calls */
				//clear the editor-buffer
				memset(pin_data->edtbuf,'\0',sizeof(pin_data->edtbuf));
				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				pins_loadEditDefault (&editor_data, TxtNull, 0);
				
				if(event == NO_SIM_CARD)
				{
					AUI_edit_SetTextStr(&editor_data, TxtNull, TxtDelete, TxtNoCard, NULL);
					AUI_edit_SetEvents(&editor_data, INSERT_CARD, FALSE, FOREVER, (T_AUI_EDIT_CB)pins_editor_cb);
				}
				else if (event == INVALID_IMEI) // Nov 24, 2005, a0876501, DR: OMAPS00045909
				{
					AUI_edit_SetTextStr(&editor_data, TxtNull, TxtDelete, TxtInvalidIMEI, NULL);
					AUI_edit_SetEvents(&editor_data, SHOW_IMEI_INVALID, FALSE, FOREVER, (T_AUI_EDIT_CB)pins_editor_cb);

				}
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS					
				//x0pleela 30 Aug, 2006 DR: OMAPS00091250
				else if ( event == NO_MEPD )
				{
					AUI_edit_SetTextStr(&editor_data, TxtNull, TxtDelete, TxtNoMEPD, NULL);
					AUI_edit_SetEvents(&editor_data, NO_MEPD_DATA, FALSE, FOREVER, (T_AUI_EDIT_CB)pins_editor_cb);

				}
#endif				
				else
				{
					AUI_edit_SetTextStr(&editor_data, TxtNull, TxtDelete, TxtInvalidCard, NULL);
					AUI_edit_SetEvents(&editor_data, CARD_REJECTED, FALSE, FOREVER, (T_AUI_EDIT_CB)pins_editor_cb);

				}
				AUI_edit_SetBuffer(&editor_data, ATB_DCS_ASCII, (UBYTE *)pin_data->edtbuf, MAX_DIG);
				AUI_edit_SetAltTextStr(&editor_data, 3, TxtNull, TRUE, TxtNull);

				/*SPR#2235 - DS - Overwrite default 'hidden' PIN entry mode */
				AUI_edit_SetMode(&editor_data, 0 /*Numeric Mode */, ED_CURSOR_UNDERLINE);
				
				pin_editor_window = AUI_pin_Start(win, &editor_data);
#else /*NEW_EDITOR */
				pins_loadEditDefault (&editor_data);

				if(event == NO_SIM_CARD)
				{
					editor_data.TextId = TxtNoCard;
					editor_data.Identifier = INSERT_CARD;	
				}
				else if(event == INVALID_IMEI) // Nov 24, 2005, a0876501, DR: OMAPS00045909
				{
					editor_data.TextId = TxtInvalidIMEI;
					editor_data.Identifier = SHOW_IMEI_INVALID;	
				}
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS					
				//x0pleela 30 Aug, 2006 DR: OMAPS00091250
				else if (event == NO_MEPD )
				{
					editor_data.TextId = TxtNoMEPD;
					editor_data.Identifier = NO_MEPD_DATA;	
				}
#endif				
				else
				{
					editor_data.TextId = TxtInvalidCard;
					editor_data.Identifier = CARD_REJECTED;	
				}

				editor_data.editor_attr.text	= pin_data->edtbuf;  /* buffer to be edited */
				editor_data.editor_attr.size	= MAX_DIG;   /* Don't limit to 3 digits (as that prevents "*#06#") */
				editor_data.LeftSoftKey 		= TxtNull;	    
				editor_data.RightSoftKey		= TxtDelete;
				editor_data.min_enter		    = 3;
				editor_data.destroyEditor	    = FALSE;

				/* create the dialog handler */
				pin_editor_window = editor_start(win, &editor_data);  /* start the editor */
#endif /* NEW_EDITOR */

		  break;
		 
		  case TXT_SIM_PLOCK:
				   pin_data->pin_case = SIM_PLOCK;
				   main_call_edit(win,SIM_PLOCK);		      // Start: enter P unlock
				   break;
		  case TXT_SIM_SPLOCK:
				   pin_data->pin_case = SIM_SPLOCK;
				   main_call_edit(win,SIM_SPLOCK);		      // Start: enter SP unlock
				   break;
		  case TXT_SIM_NLOCK:
				   pin_data->pin_case = SIM_NLOCK;
				   main_call_edit(win,SIM_NLOCK);		      // Start: enter N unlock
				   break;
		  case TXT_SIM_CLOCK:
				   pin_data->pin_case = SIM_CLOCK;
				   main_call_edit(win,SIM_CLOCK);		      // Start: enter C unlock
				   break;
		  case TXT_SIM_NSLOCK:
				   pin_data->pin_case = SIM_NSLOCK;
				   main_call_edit(win,SIM_NSLOCK);		      // Start: enter NS unlock
				   break;



	 }

	switch(event)
	{
	  case PIN_OK_INFO: // PIN was needed
	  case PIN_OK:	    // PIN wasn't needed
				check_plock_to_clock(win,event);/* start sim lock procedure   */
			   break;
	  case PIN_OK_END:
		{
			BootUpState = BOOTUP_STATE_COMPLETED;//xashmic 21 Sep 2006, OMAPS00095831

//		   U8 uMode;  /* Warning Correction */
			/*
			*** registration in full service mode case: PIN was  necessary
			*/
				/* SH - show welcome screen */
				showwelcome(idle_get_window());

			    network_start_full_service ();
//GW-SPR#1035-Added STK Changes
				TRACE_FUNCTION("pin_destroy 2");
	  }			
		       break;
//nm insert new one
	  case PIN1_STATUS_END:
			   pin_destroy(pin_data->pin_win);// finish main pin dialog
			   TRACE_FUNCTION("pin_destroy 3");
		       break;
//nm		       
	  case TXT_SIM_LOCK_ALL:
	  		ShowMessage(idle_get_window(), pin_data->display_id1, pin_data->display_id2);
			   pin_destroy(pin_data->pin_win);// finish main pin dialog
			   TRACE_FUNCTION("pin_destroy 4");
		       break;
	  case PUK1_UNBL_SUCC:
			if((pin_data->pin_case EQ PUK1_END) || (pin_data->gsm_state && (pin_data->pin_case EQ INPUT_PUK1)))
						/*	 sim lock check only after power on and puk verified */
				   /* by PUK (normal way) or by gsm unblock string */
			{
				check_plock_to_clock(win,event);
			}
			else
			{

				main_call_mess(win,event);		   
	 
			}
			break;
	}

	switch(event)
	{


	  case SIM_NLOCK_REQ:
	  case SIM_NSLOCK_REQ:
	  case SIM_SPLOCK_REQ:
	  case SIM_CLOCK_REQ:
			main_call_mess(win,event);
			break;
	  case SIM_PLOCK:
			check_nlock_to_clock(win,event);
			break;
	  case SIM_NLOCK:
			check_splock_to_clock(win,event);
			break;
	  case SIM_SPLOCK:
			check_nslock_to_clock(win,event);
			break;
	  case SIM_NSLOCK:
			check_sim_clock(win,event);
			break;
	  case SIM_CLOCK:
			if(sim_unlock_sim_lock(MFW_SIM_CLOCK,(UBYTE *)pin_data->pin)EQ MFW_SIM_CLOCK)/* unlock code  */
			{
					main_call_mess(win,SIM_UNLOCK_OK);	      /* finish sim unlock procedure */
			}
			else if(sim_unlock_sim_lock(MFW_SIM_CLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_UNLOCK_ERR)
			{
				main_call_mess(win,SIM_LOCK_ERR);
			}
			break;
	  default:
		  break;
	}
}


/*******************************************************************************

 $Function:	check_plock_to_clock 

 $Description:	sim lock check from PLOCK to CLOCK
 $Returns:		void
 $Arguments:	window, window handler event
 
*******************************************************************************/
static void check_plock_to_clock(T_MFW_HND win,USHORT event)
{
	/* x0045876, 14-Aug-2006 (WR - "win_data" was declared but never referenced) */
	/* T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data; */
	
//	T_pin * pin_data = (T_pin *)win_data->user; // pin main data  /* Warning Correction */

	TRACE_FUNCTION("MmiPins:check_plock_to_clock");
	/*MC SPR 1351 check all locks other than Plock for being blocked as well as locked.  User can
	then attempt to enter overall PUK to disable lock if need be*/
	if(sim_check_sim_Plock() EQ MFW_SIM_BLOCKED)
	{
		main_call_mess(win,SIM_LOCK_ALL);
	}
	else if(sim_check_sim_Plock() EQ MFW_SIM_LOCKED)
	{
		main_call_mess(win,SIM_PLOCK_REQ);
	}
	else if(sim_check_sim_Nlock() EQ MFW_SIM_LOCKED ||sim_check_sim_Nlock() EQ MFW_SIM_BLOCKED)
	{
		main_call_mess(win,SIM_NLOCK_REQ);
	}
	else if(sim_check_sim_SPlock() EQ MFW_SIM_LOCKED||sim_check_sim_SPlock() EQ MFW_SIM_BLOCKED)
	{
		main_call_mess(win,SIM_SPLOCK_REQ);
	}
	else if(sim_check_sim_NSlock() EQ MFW_SIM_LOCKED ||sim_check_sim_NSlock() EQ MFW_SIM_BLOCKED)
	{
		main_call_mess(win,SIM_NSLOCK_REQ);
	}
	else if(sim_check_sim_Clock() EQ MFW_SIM_LOCKED|| sim_check_sim_Clock() EQ MFW_SIM_BLOCKED)
	{
		main_call_mess(win,SIM_CLOCK_REQ);
	}
	else
	{
		switch(event)
		{
			case PIN_OK:

				/*
				*** registration in full service mode case: PIN was not necessary
				*/
				/* SH - show welcome screen*/
				showwelcome(idle_get_window());
				/*SPR 1431*/
				network_start_full_service();
//GW-SPR#1035-Added STK Changes
/* NM, 110702
   this destroy the only ONE SIM-handler which we have 
   after switching on !!
   It should be at least one SIM-handler activ all the  time 
*/
				TRACE_FUNCTION("pin_destroy 5");
				break;
			case PIN_OK_INFO:
				main_call_mess(win,PIN_OK_INFO);
				break;
			case PUK1_UNBL_SUCC:
				main_call_mess(win,event);
				break;
			default:
				break;
		}
	}
}


/*******************************************************************************

 $Function:	check_nlock_to_clock
 $Description:	sim lock check from NLOCK to CLOCK
 $Returns:		void
 $Arguments:	window, window handler event
 
*******************************************************************************/
static void check_nlock_to_clock(T_MFW_HND win,USHORT event)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	TRACE_FUNCTION("MmiPins:check_nlock_to_clock");

	if(sim_unlock_sim_lock(MFW_SIM_PLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_PLOCK)/* P unlock code ok */
	{	/*MC SPR 1351 check locks for being blocked as well as locked.  User can
		then attempt to enter overall PUK to disable lock*/
		if(sim_check_sim_Nlock() EQ MFW_SIM_LOCKED || sim_check_sim_Nlock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_NLOCK_REQ);	      //check N unlock code
		}
		else if(sim_check_sim_SPlock() EQ MFW_SIM_LOCKED || sim_check_sim_SPlock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_SPLOCK_REQ);	      //check SP unlock code
		}
		else if(sim_check_sim_NSlock() EQ MFW_SIM_LOCKED || sim_check_sim_NSlock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_NSLOCK_REQ);	      //check NS unlock code
		}
	else if(sim_check_sim_Clock() EQ MFW_SIM_LOCKED || sim_check_sim_Clock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_CLOCK_REQ);	      //check C unlock code
		}
		else					      /* finish sim unlock procedure */
		{
			main_call_mess(win,SIM_UNLOCK_OK);
		}
	}
	else if(sim_unlock_sim_lock(MFW_SIM_PLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_UNLOCK_ERR)
	{
			main_call_mess(win,SIM_LOCK_ERR);
	}
}


/*******************************************************************************

 $Function:	check_splock_to_clock
 $Description:	sim lock check from SPLOCK to CLOCK
 $Returns:		void
 $Arguments:	window, window handler event
 
*******************************************************************************/
static void check_splock_to_clock(T_MFW_HND win,USHORT event)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	TRACE_FUNCTION("MmiPins:check_splock_to_clock");

	if(sim_unlock_sim_lock(MFW_SIM_NLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_NLOCK)
	{/*MC SPR 1351 check locks for being blocked as well as locked.  User can
		then attempt to enter overall PUK to disable lock*/
		if(sim_check_sim_SPlock() EQ MFW_SIM_LOCKED || sim_check_sim_SPlock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_SPLOCK_REQ);	      //check SP unlock code
		}
		else if(sim_check_sim_NSlock() EQ MFW_SIM_LOCKED|| sim_check_sim_NSlock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_NSLOCK_REQ);	      //check NS unlock code
		}
	else if(sim_check_sim_Clock() EQ MFW_SIM_LOCKED || sim_check_sim_Clock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_CLOCK_REQ);	      //check C unlock code
		}
		else					      /* finish sim unlock procedure */
		{
			main_call_mess(win,SIM_UNLOCK_OK);	      /* finish sim unlock procedure */
		}
	}
	else if(sim_unlock_sim_lock(MFW_SIM_NLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_UNLOCK_ERR)
	{
		main_call_mess(win,SIM_LOCK_ERR);
	}
}


/*******************************************************************************

 $Function:	check_nslock_to_clock
 $Description:	sim lock check from NSLOCK to CLOCK
 $Returns:		void
 $Arguments:	window, window handler event
 
*******************************************************************************/
static void check_nslock_to_clock(T_MFW_HND win,USHORT event)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	TRACE_FUNCTION("MmiPins:check_nslock_to_clock");

	if(sim_unlock_sim_lock(MFW_SIM_SPLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_SPLOCK)/* unlock code ok */
	{/*MC SPR 1351 check locks for being blocked as well as locked.  User can
		then attempt to enter overall PUK to disable lock*/
		if(sim_check_sim_NSlock() EQ MFW_SIM_LOCKED || sim_check_sim_NSlock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_NSLOCK_REQ);	      //check NS unlock code
		}
	else if(sim_check_sim_Clock() EQ MFW_SIM_LOCKED || sim_check_sim_Clock() EQ MFW_SIM_BLOCKED)
		{
			main_call_mess(win,SIM_CLOCK_REQ);	      //check C unlock code
		}
		else					      /* finish sim unlock procedure */
		{
			main_call_mess(win,SIM_UNLOCK_OK);	      /* finish sim unlock procedure */
		}
	}
	else if(sim_unlock_sim_lock(MFW_SIM_SPLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_UNLOCK_ERR)
	{
		main_call_mess(win,SIM_LOCK_ERR);
	}
}


/*******************************************************************************

 $Function:	check_sim_clock
 $Description:	sim lock check	CLOCK
 $Returns:		void
 $Arguments:	window, window handler event
 
*******************************************************************************/
static void check_sim_clock(T_MFW_HND win,USHORT event)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	TRACE_FUNCTION("MmiPins:check_sim_lock");

	if(sim_unlock_sim_lock(MFW_SIM_NSLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_NSLOCK)/* unlock code ok */
	{/*MC SPR 1351 check locks for being blocked as well as locked.  User can
		then attempt to enter overall PUK to disable lock*/
      if(sim_check_sim_Clock() EQ MFW_SIM_LOCKED || sim_check_sim_Clock() EQ MFW_SIM_BLOCKED)
	  {
		main_call_mess(win,SIM_CLOCK_REQ);		  //check C unlock code
	   }
		else					      /* finish sim unlock procedure */
		{
			main_call_mess(win,SIM_UNLOCK_OK);	      /* finish sim unlock procedure */
		}
	}
	else if(sim_unlock_sim_lock(MFW_SIM_NSLOCK,(UBYTE *)pin_data->pin) EQ MFW_SIM_UNLOCK_ERR)
	{
		main_call_mess(win,SIM_LOCK_ERR);
	}
}

/*******************************************************************************

 $Function:	main_call_mess 
 $Description:	help function for message dialog
 $Returns:		void
 $Arguments:	window, window handler event
 
*******************************************************************************/
static void main_call_mess(T_MFW_HND win, USHORT event)
{

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	T_MFW_HND pin_mess_win;
	TRACE_FUNCTION("MmiPins: main_call_mess");

	pin_mess_win = pin_mess_create(pin_data->pin_win);
	
	if(pin_mess_win)
	{
		SEND_EVENT(pin_mess_win,event,0,pin_data);
	}
}


/*******************************************************************************

 $Function:	main_call_edit 
 $Description:	help function for editor dialog
 $Returns:		void
 $Arguments:	window, window handler event
 
*******************************************************************************/
static void main_call_edit(T_MFW_HND win,USHORT event)
{

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	T_MFW_HND pin_edt_win;




	pin_edt_win = pin_edt_create(pin_data->pin_win);

    if(pin_edt_win)
	{
		SEND_EVENT(pin_edt_win,event,0,pin_data);
	}
}


/*******************************************************************************

 $Function:	pin_edt_create 
 $Description:	Creation of an instance  for the PIN Editor dialog.
		Type of dialog : SINGLE_DYNAMIC
 $Returns:		void
 $Arguments:	parent window
 
*******************************************************************************/
T_MFW_HND pin_edt_create (T_MFW_HND parent_window)
{
  T_pin_edt * data = (T_pin_edt *)ALLOC_MEMORY (sizeof (T_pin_edt));

  T_MFW_WIN * win;

  data->pin_edt_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)pin_edt_win_cb);
  TRACE_FUNCTION("pin_edt_create");

  if (data->pin_edt_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  pin_edit_windows = data->pin_edt_win;
  data->mmi_control.dialog    = (T_DIALOG_FUNC)pin_editor;
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_edt_win)->data;
  win->user		      = (void *) data;

  /*
   * Create any other handler
   */

  data->tim_out_handle = tim_create(data->pin_edt_win,TIMEOUT,(T_MFW_CB)pin_edt_tim_out_cb);

  /* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
  data->editor = ATB_edit_Create(&data->editorPinAttr,0);
#else /* NEW_EDITOR */
  data->editor_handle = edt_create(data->pin_edt_win,&data->editpinAttr,0,0);
#endif /* NEW_EDITOR */

  data->kbd_handle = kbd_create(data->pin_edt_win,KEY_ALL,(T_MFW_CB)pin_edt_kbd_cb);
  data->kbd_long_handle = kbd_create(data->pin_edt_win,KEY_ALL | KEY_LONG,(T_MFW_CB)pin_edt_kbd_long_cb);
  /*
   * return window handle
   */
  return data->pin_edt_win;
}


/*******************************************************************************

 $Function:	pin_edt_destroy 
 $Description:	Destroy the pin editor dialog.
 $Returns:		void
 $Arguments:	window
 
*******************************************************************************/
void pin_edt_destroy  (T_MFW_HND own_window)
{
  T_pin_edt * data ;
  T_MFW_WIN * win;


  if (own_window)
  {
	  TRACE_FUNCTION("pin_edt_destroy");
	  win = ((T_MFW_HDR *)own_window)->data;
	  data = (T_pin_edt *)win->user;

	  if(data)
	  {
      /*
       * Delete WIN Handler and children handler
       */
		  pin_edit_windows = 0;
		  win_delete (data->pin_edt_win);
	      FREE_MEMORY((void *)data,(sizeof(T_pin_edt)));;
	  }
   }
}


/*******************************************************************************

 $Function:	pin_edt_win_cb
 $Description:	Callback function for editor windows
 $Returns:		Status int
 $Arguments:	window handle event, window
 
*******************************************************************************/
static int pin_edt_win_cb (T_MFW_EVENT event,T_MFW_WIN * win)
{
  T_pin_edt 	*edt_data	= (T_pin_edt *)win->user;//pin edt data
  T_MFW_WIN		*win_pin	=((T_MFW_HDR *)edt_data->parent_win)->data;
  T_pin			*pin_data	= (T_pin *)win_pin->user; // pin main data

  TRACE_EVENT_P1("pin_edt_win_cb: %d", event);
  
  if (event EQ MfwWinVisible)
  {
  /* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
	ATB_edit_Show(edt_data->editor);

	/* ED_UPDATE_TRIVIAL only updates text, not title */
	if (edt_data->editor->update!=ED_UPDATE_TRIVIAL)
	{
		/* Set the colour for drawing title */

		resources_setTitleColour(COLOUR_EDITOR);
		PROMPT(0,0,0,pin_data->display_id1);

		dspl_Clear(0,0, SCREEN_SIZE_X-1, edt_data->editor->attr->win_size.py-1);
	}

	edt_data->editor->update = ED_UPDATE_DEFAULT;
	
#else /* NEW_EDITOR */
    pin_icons();
    PROMPT(INFO_TEXT_X,INFO_TEXT_Y,0,pin_data->display_id1);
#endif /* NEW_EDITOR */

    return 1;
  }
  return 0;
}


/*******************************************************************************

 $Function:	pin_edt_kbd_cb 
 $Description:	Callback function for keyboard
 $Returns:		Status int
 $Arguments:	window handle event, keyborad control block
 
*******************************************************************************/
static int pin_edt_kbd_cb (T_MFW_EVENT event,T_MFW_KBD *  kc)
{
    T_MFW_HND win = mfw_parent(mfw_header());

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;//pin edt data

	T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
	T_pin * pin_data = (T_pin *)win_pin->user; // pin main data
//	T_sim_rem * sim_rem_data = (T_sim_rem *)win_pin->user; //sim_rem data possible too  /* Warning Correction */

	char timer = TRUE;
	timStop(edt_data->tim_out_handle);/* stop entering timer      */

	TRACE_FUNCTION("MmiPins:pin_edt_kbd_cb");
		switch(kc->code)
		{
			case KCD_0:
			case KCD_1:
			case KCD_2:
			case KCD_3:
			case KCD_4:
			case KCD_5:
			case KCD_6:
			case KCD_7:
			case KCD_8:
			case KCD_9:
			case KCD_STAR:
				if(edt_data->editor_index < MAX_DIG)
				{
					if(kc->code EQ KCD_STAR)
						edt_data->pin[edt_data->editor_index] = STAR;
					else
						edt_data->pin[edt_data->editor_index] = '0' + kc->code;
// Nov 24, 2005, a0876501, DR: OMAPS00045909
		   			if((edt_data->pin_case_edit NEQ CARD_REJECTED) AND (edt_data->pin_case_edit NEQ INSERT_CARD) 
						AND (edt_data->pin_case_edit NEQ SHOW_IMEI_INVALID)
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS							
						//x0pleela 30 Aug, 2006 DR: OMAPS00091250
						AND (edt_data->pin_case_edit NEQ NO_MEPD_DATA) 
#endif
						)
					{
					/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
						ATB_edit_AsciiChar(edt_data->editor, '*', TRUE);
#else /* NEW_EDITOR */
						edtChar(edt_data->editor_handle,'*');			       /* hide security code */
#endif /* NEW_EDITOR */
					}
					else
					{
					/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
						ATB_edit_AsciiChar(edt_data->editor, edt_data->pin[edt_data->editor_index], TRUE);
#else /* NEW_EDITOR */
						edtChar(edt_data->editor_handle,edt_data->pin[edt_data->editor_index]); /* not hide emergency call */
#endif /* NEW_EDITOR */
					}
						
					edt_data->editor_index++;
					check_pins(win, edt_data);		    /*	digits check depends on status pin_case */
					if(edt_data->gsm_state)
						pin_data->gsm_state = edt_data->gsm_state;

				}
				break;
			case KCD_HASH:
			case KCD_LEFT:
					switch(edt_data->pin_case_edit)
					{

						case INSERT_CARD:
						case CARD_REJECTED:
						case SHOW_IMEI_INVALID: // Nov 24, 2005, a0876501, DR: OMAPS00045909
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS							
						//x0pleela 30 Aug, 2006 DR: OMAPS00091250
						case NO_MEPD_DATA:
#endif							
							if(edt_data->emergency_call)
							{
								emerg_pin(edt_data);				/* start emergency call  */
								timer = FALSE;
							}
							else
							{
								clear_edit_array (edt_data);
								memset(edt_data->pin,'\0', sizeof(edt_data->pin));/* initial string */
								edt_data->editor_index = 0;
							}
							break;
						case SIM_PLOCK:
							timer = FALSE;
							strncpy((char*)pin_data->pin,(char*)edt_data->pin,MAX_PIN);
							pin_edt_destroy(edt_data->pin_edt_win);
			    SEND_EVENT(pin_data->pin_win,SIM_PLOCK,0,pin_data);//check P unlock code
							break;
						case SIM_NLOCK:
							strncpy((char*)pin_data->pin,(char*)edt_data->pin,MAX_PIN);
							pin_edt_destroy(edt_data->pin_edt_win);
							timer = FALSE;
			    SEND_EVENT(pin_data->pin_win,SIM_NLOCK,0,pin_data);
							break;
						case SIM_SPLOCK:
							strncpy((char*)pin_data->pin,(char*)edt_data->pin,MAX_PIN);
							pin_edt_destroy(edt_data->pin_edt_win);
							timer = FALSE;
			    SEND_EVENT(pin_data->pin_win,SIM_SPLOCK,0,pin_data);
							break;
						case SIM_NSLOCK:
							strncpy((char*)pin_data->pin,(char*)edt_data->pin,MAX_PIN);
							pin_edt_destroy(edt_data->pin_edt_win);
							timer = FALSE;
						    SEND_EVENT(pin_data->pin_win,SIM_NSLOCK,0,pin_data);
							break;
						case SIM_CLOCK:
							strncpy((char*)pin_data->pin,(char*)edt_data->pin,MAX_PIN);
							pin_edt_destroy(edt_data->pin_edt_win);
							timer = FALSE;
						    SEND_EVENT(pin_data->pin_win,SIM_CLOCK,0,pin_data);
							break;
						default:
							break;
					}
					break;
			case KCD_HUP:
			case KCD_RIGHT:
				    if(edt_data->editor_index EQ 0)
						;
					else
						edt_data->editor_index--;

					edt_data->pin[edt_data->editor_index] = '\0';
					/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
					ATB_edit_DeleteLeft(edt_data->editor, TRUE); /* SPR#2342 - SH */
#else /* NEW_EDITOR */
					edtChar(edt_data->editor_handle,ecBack);/* delete character    */

					if(strlen((char*)edt_data->pin) < MIN_PIN)
					{
						TRACE_FUNCTION("clear softknr 4");
						pin_rectClear( &edt_data->editpinAttr.win );
					}
#endif /* NEW_EDITOR */
					edt_data->emergency_call = FALSE;
					if(edt_data->pin_case_edit EQ INPUT_PUK1)  /* special case ?? */
						winShow(edt_data->pin_edt_win);
					else
						check_pins(win,edt_data);	   /* check remain for emergency call  */
				    break;
			default:
				break;
		}
	if (timer)
		tim_start(edt_data->tim_out_handle);/* start timer for entering */
	return MFW_EVENT_CONSUMED;
}


/*******************************************************************************

 $Function:	check_pins  
 $Description:	check pins input string
 $Returns:		none
 $Arguments:	window, pin editor attributes
 
*******************************************************************************/
static void check_pins (T_MFW_HND win, void * edt_pin)
{
	T_pin_edt * edt_data = (T_pin_edt *)edt_pin;

	TRACE_FUNCTION("MmiPins:check_pins");

	if(strlen((char*)edt_data->pin)NEQ 0)
    {
		softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);	
	    if (strlen((char*)edt_data->pin) > FIRST_DIGIT)	       /* for every character  */
	    {
			if(strlen((char*)edt_data->pin) >= 3)
			{

				TRACE_FUNCTION("Softkeys:nr 1");
				softKeys_displayId(TxtSoftOK,TxtDelete,0, COLOUR_EDITOR_XX);
			}
			else
				softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);

			gsm_test(win,edt_data); 	  /* test if GSM string or not*/
		}
		
	    TRACE_FUNCTION("Check Length of PIN");
		if (strlen((char*)edt_data->pin) EQ (MIN_PIN - 1) || strlen((char*)edt_data->pin) EQ (MIN_PIN -2))
		{
			TRACE_FUNCTION("cm_check_emergency() TRACE PINS 2");
			if(cm_check_emergency((U8*)edt_data->pin))/* test emergency call*/
			{
				TRACE_FUNCTION("MmiPins:check_pins:emercall");
				edt_data->emergency_call = TRUE;
				softKeys_displayId(TxtSoftCall,TxtNull,0, COLOUR_EDITOR_XX);	
			}
			else
			{
// Nov 24, 2005, a0876501, DR: OMAPS00045909
				if((edt_data->pin_case_edit EQ CARD_REJECTED) OR (edt_data->pin_case_edit EQ INSERT_CARD) 
					OR (edt_data->pin_case_edit EQ SHOW_IMEI_INVALID)
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS	
					//x0pleela 30 Aug, 2006 DR: OMAPS00091250
					OR (edt_data->pin_case_edit EQ NO_MEPD_DATA)
#endif
					)
				{			  /* delete all digits	    */
					clear_edit_array (edt_data);  /*  clear editor array	 */
					memset(edt_data->pin, '\0', sizeof(edt_data->pin));/* initial string */
					edt_data->editor_index = 0;
				}
				edt_data->emergency_call = FALSE;
			}
		}
		if ((strlen((char*)edt_data->pin) >= MIN_PIN) && (strlen((char*)edt_data->pin) < (MAX_PIN + 1)))
		{
// Nov 24, 2005, a0876501, DR: OMAPS00045909
			if(((edt_data->pin_case_edit EQ CARD_REJECTED) OR (edt_data->pin_case_edit EQ INSERT_CARD)
				OR (edt_data->pin_case_edit EQ SHOW_IMEI_INVALID)				
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS					
				//x0pleela 30 Aug, 2006 DR: OMAPS00091250
				OR (edt_data->pin_case_edit EQ NO_MEPD_DATA)
#endif
			) && !(edt_data->gsm_state))
			{
				if(edt_data->editor_index EQ 0)
					;
				else
					edt_data->editor_index--;		  /* only emergency calls, 3 digits */

				edt_data->pin[edt_data->editor_index] = '\0';
				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				ATB_edit_DeleteLeft(edt_data->editor, TRUE); /* SPR#2342 - SH */
#else /* NEW_EDITOR */
				edtChar(edt_data->editor_handle,ecBack);
#endif /* NEW_EDITOR */

			}
			else
			{
				TRACE_FUNCTION("clear softknr 5");

				if(((edt_data->pin_case_edit EQ INPUT_PUK1) ||(edt_data->pin_case_edit EQ INPUT_PUK2)) && !(edt_data->gsm_state))
				{	    /* PUK 1/2 (not by gsm string) max. 8 digits  */
					if(strlen((char*)edt_data->pin) >= MAX_PIN)
					{
						TRACE_FUNCTION("Softkeys:nr 2");
					}
				}
				else if((edt_data->pin_case_edit EQ SIM_CLOCK) ||
					    (edt_data->pin_case_edit EQ SIM_NLOCK) ||
						(edt_data->pin_case_edit EQ SIM_NSLOCK) ||
						(edt_data->pin_case_edit EQ SIM_SPLOCK))
				{	     /* sim lock code  max. 8 digits exept PLOCK  */
					if(strlen((char*)edt_data->pin) >= MAX_PIN)
					{
						TRACE_FUNCTION("Softkeys:nr 3");
					}
				}
				else if (edt_data->pin_case_edit EQ SIM_PLOCK)
				{		   /* sim lock	PLOCK code  max. 6 digits */
					if(strlen((char*)edt_data->pin) >= NUM_OF_PLOCK)
					{
						TRACE_FUNCTION("Softkeys:nr 4");
					}
				}
				else
				{
					if(!(edt_data->gsm_state))	  /* usual way for PIN 4 digits     */
					{
					  TRACE_FUNCTION("softkey 5");
						
					}
					else
					{
						TRACE_FUNCTION("clear softkey 6");
						pin_skClear(  );
//						dspl_Clear( PIN_EDIT_2 ); /* clear button */
					}
				}
				edt_data->emergency_call = FALSE;
			}
		}
		if((strlen((char*)edt_data->pin) > MAX_PIN) && !(edt_data->gsm_state)) /* >8 digits not allowed    */
		{
			if(edt_data->editor_index EQ 0)
				;
			else
				edt_data->editor_index--;

			edt_data->pin[edt_data->editor_index] = '\0';
			/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
			ATB_edit_DeleteLeft(edt_data->editor, TRUE); /* SPR#2342 - SH */
#else /* NEW_EDITOR */
			edtChar(edt_data->editor_handle,ecBack);
#endif /* NEW_EDITOR */
		}
	}
}


/*******************************************************************************

 $Function:	gsm_test 
 $Description:	test if gsm string
 $Returns:		Status int
 $Arguments:	window, pin editor attributes
 
*******************************************************************************/
static int gsm_test(T_MFW_HND win,void * edt_pin)
{
	int status;
	T_pin_edt * edt_data = (T_pin_edt *)edt_pin;

	//T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data; /* Warning Correction */
	T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
	T_pin * pin_data = (T_pin *)win_pin->user; // pin main data

	TRACE_FUNCTION("MmiPins:gsm_test");

	status = ss_check_ss_string((UBYTE*)edt_data->pin);/* check GSM-String */
	switch(status)
	{
		case MFW_SS_SIM_UNBLCK_PIN:
			if(!(edt_data->gsm_state))
			{
				switch(edt_data->pin_case_edit)
				{
					case INPUT_PUK1:/* replace * with string id */
						if(!(strncmp((char*)edt_data->pin,"**05*",IDENT_GSM_1)))
						{
							edt_data->gsm_state = TRUE;
							strncpy((char*)edt_data->edtbuf,(char*)edt_data->pin,edt_data->editor_index-1);
							/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
							ATB_edit_Show(edt_data->editor);
#else /* NEW_EDITOR */
							edtShow(edt_data->editor_handle);
#endif /* NEW_EDITOR */
						}
						else
						{
							edt_data->gsm_state = FALSE;
							TRACE_EVENT("dsplClearAll 2");								
							dspl_ClearAll();
							clear_edit_array (edt_data);
							pin_edt_destroy(edt_data->pin_edt_win);
							SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
						}
						break;
					default:
						edt_data->gsm_state = FALSE;
						TRACE_EVENT("dsplClearAll 3");							
						dspl_ClearAll();
						clear_edit_array (edt_data);
						pin_edt_destroy(edt_data->pin_edt_win);
						SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
						break;
				}
			}
			return status;
		case MFW_SS_DIAL:	       /* string not yet detected  */
        case MFW_SS_USSD:  /*JVJ SPR 1040- The short USSD strings should also be 
                              considered in this case, since they can be confused with dialled numbers  
                             */
				edt_data->gsm_state = FALSE;
			return status;
		default:
			TRACE_FUNCTION("MmiPins:default in gsm_test");		
			edt_data->gsm_state = FALSE;
			TRACE_FUNCTION("dsplClearAll 4");							
			dspl_ClearAll();
			clear_edit_array (edt_data);
			pin_edt_destroy(edt_data->pin_edt_win);
			SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
			return status;
	}
}


#if(0) /* x0039928 - Lint warning fix */
/*******************************************************************************

 $Function:	gsm_sec_execute
 $Description:	GSM-String will be executed
 $Returns:		None
 $Arguments:	window, string
 
*******************************************************************************/
static void gsm_sec_execute(T_MFW_HND win,void *string)
{

	T_pin_edt * edt_data = (T_pin_edt *)string;

//	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;   /* Warning Correction */
	T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
	T_pin * pin_data = (T_pin *)win_pin->user; // pin main data

	int result;

	TRACE_FUNCTION("MmiPins:gsm_sec_execute");

	result = ss_execute_transaction((UBYTE*)edt_data->pin,0);/* ussd_man = 0 while SSD */

	TRACE_FUNCTION("dsplClearAll 5"); 
	dspl_ClearAll();
	clear_edit_array (edt_data);
	pin_edt_destroy(edt_data->pin_edt_win);

	switch(result)
	{
		case MFW_SS_SIM_REG_PW: 	/* change PIN1/2	     */
	    TRACE_FUNCTION("MmiPins:gsm_sec_execute:MFW_SS_SIM_REG_PW");
			break;
		case MFW_SS_SIM_UNBLCK_PIN:	/* unblock PIN1/2	    */
	    TRACE_FUNCTION("MmiPins:gsm_sec_execute:MFW_SS_SIM_UNBLCK_PIN");
			break;
		case MFW_SS_FAIL:
	    TRACE_FUNCTION("MmiPins:gsm_sec_execute:MFW_SS_FAIL");
			SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/* new PIN and new PIN again are not the same */
			break;
		default:
			break;
	}
}

#endif

/*******************************************************************************

 $Function:	pin_edt_kbd_long_cb
 $Description:	Callback function for keyboard long
 $Returns:		Status int
 $Arguments:	window handler event, keyboard control block 
 
*******************************************************************************/
static int pin_edt_kbd_long_cb (T_MFW_EVENT event,T_MFW_KBD *  kc)
{
    T_MFW_HND win = mfw_parent(mfw_header());

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;//pin edt data

    TRACE_FUNCTION("MmiPins:pin_edt_kbd_long_cb");

    if ((event & KEY_CLEAR) && (event & KEY_LONG))
	{
			timStop(edt_data->tim_out_handle); /* stop entering timer	*/
			clear_edit_array(edt_data);
			memset(edt_data->pin,'\0',sizeof(edt_data->pin));/* initial string */
			edt_data->editor_index = 0;
			edt_data->emergency_call = FALSE;
			winShow(edt_data->pin_edt_win);
			return MFW_EVENT_CONSUMED;
	}
  return MFW_EVENT_CONSUMED;
}




/*******************************************************************************

 $Function:	pin_edt_tim_out_cb
 $Description:	Callback function for timer (watchdog entering)
 $Returns:		void
 $Arguments:	window handler event, timer control block 
 
*******************************************************************************/
static void pin_edt_tim_out_cb (T_MFW_EVENT event,T_MFW_TIM * t)
{
    T_MFW_HND win = mfw_parent(mfw_header());

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;

	T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
	T_pin * pin_data = (T_pin *)win_pin->user; // pin main data

    TRACE_FUNCTION("MmiPins:pin_edt_tim_out_cb");


    TRACE_FUNCTION("clear softkey 7");

	// clear the softkeys
	pin_skClear();
	clear_edit_array(edt_data);
	// clear the input
	
	/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
	ATB_edit_ClearAll(edt_data->editor);
#else /* NEW_EDITOR */
	pin_rectClear( &edt_data->editpinAttr.win );
    memset(edt_data->pin, '\0', sizeof(edt_data->pin));/* initial string  */
#endif /* NEW_EDITOR */

	edt_data->editor_index = 0;
	edt_data->gsm_state = FALSE;
	pin_data->gsm_state = FALSE;

	winShow(edt_data->pin_edt_win);
}



/*******************************************************************************

 $Function:	pin_editor 
 $Description:	Pin editor Dialog Signal Handling function
 $Returns:		void
 $Arguments:	window, window handler event, value, parameter 
 
*******************************************************************************/
static void pin_editor(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;


    T_pin * pin_data = (T_pin *)parameter;//pin main data

	edt_data->pin_case_edit = pin_data->pin_case;

	TRACE_FUNCTION("MmiPins:pin_editor");

  /*
   * depending on event
   */
  switch (event)
  {
	case INPUT_PIN1:
	case INPUT_PUK1:
	case INPUT_NEW_PIN:
	case INPUT_NEW_PIN_AGAIN:
	case CARD_REJECTED:
	case INSERT_CARD:
	case SHOW_IMEI_INVALID:	// Nov 24, 2005, a0876501, DR: OMAPS00045909
	case SIM_PLOCK:
	case SIM_NLOCK:
	case SIM_NSLOCK:
	case SIM_SPLOCK:
	case SIM_CLOCK:
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS			
	case NO_MEPD_DATA: //x0pleela 30 Aug, 2006 DR: OMAPS00091250
#endif
		
		//SPR#717 - GW - Wrong structures being cleared
		memset(edt_data->pin, '\0', sizeof(edt_data->pin));/* initial string  */
		memset(edt_data->puk, '\0', sizeof(edt_data->puk));
		memset(edt_data->new_pin, '\0', sizeof(edt_data->new_pin));
		memset(edt_data->old_pin, '\0', sizeof(edt_data->old_pin));

		// the coordinate of the editor (enter the pin)
		/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
		AUI_edit_SetAttr( &edt_data->editorPinAttr, PIN_EDIT_RESET, COLOUR_EDITOR_XX, EDITOR_FONT, 0, ED_CURSOR_UNDERLINE, ATB_DCS_ASCII, (UBYTE *)edt_data->edtbuf, MAX_DIG);
		clear_edit_array(edt_data);          /*    clear editor buffer      */
		ATB_edit_Init(edt_data->editor);
#else /* NEW_EDITOR */
		editor_attr_init( &edt_data->editpinAttr, PIN_EDIT_RESET, edtCurBar1,0,(char*)edt_data->edtbuf,MAX_DIG,COLOUR_EDITOR_XX);
		clear_edit_array(edt_data);          /*    clear editor buffer      */
#endif /* NEW_EDITOR */

		edt_data->editor_index = 0;
		winShow(edt_data->pin_edt_win);
	break;
	default:
		break;
  }
}


/*******************************************************************************

 $Function:	pin_mess_create 
 $Description:	Creation of an instance  for the PIN Message dialog.
		Type of dialog : SINGLE_DYNAMIC
 $Returns:		window
 $Arguments:	parent win
 
*******************************************************************************/
T_MFW_HND pin_mess_create (T_MFW_HND parent_window)
{
  T_pin_mess * data = (T_pin_mess *)ALLOC_MEMORY (sizeof (T_pin_mess));

  T_MFW_WIN	* win;

  data->pin_mess_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)pin_mess_win_cb);

  TRACE_FUNCTION("MmiPins:pin_mess_create");

  if (data->pin_mess_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  pin_mess_windows = data->pin_mess_win;
  data->mmi_control.dialog    = (T_DIALOG_FUNC)pin_messages;
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_mess_win)->data;
  win->user		      = (void *) data;

  /*
   * return window handle
   */
  return data->pin_mess_win;
}


/*******************************************************************************

 $Function:	pin_mess_destroy 
 $Description:	Destroy the pin message dialog.
 $Returns:		none
 $Arguments:	win
 
*******************************************************************************/
void pin_mess_destroy  (T_MFW_HND own_window)
{
  T_pin_mess * data;
  T_MFW_WIN * win;

  if (own_window)
  {
	TRACE_FUNCTION("MmiPins:pin_mess_destroy ");

	  win = ((T_MFW_HDR *)own_window)->data;
	  data = (T_pin_mess *)win->user;

	  if(data)
	  {

      /*
       * Delete WIN Handler
       */
      
		  pin_mess_windows = 0;
	  win_delete (data->pin_mess_win);
	      FREE_MEMORY((void *)data,(sizeof(T_pin_mess)));
	  }
   }
}

/*******************************************************************************

 $Function:	pin_mess_win_cb 
 $Description:	Callback function for message windows
 $Returns:		Status int
 $Arguments:	event, window
 
*******************************************************************************/
static int pin_mess_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
  /*
   * Top Window has no output
   */
  return 1;
}




/*******************************************************************************

 $Function:	pin_messages
 $Description:	Pin message Dialog Handling function
 $Returns:		none
 $Arguments:	window, event, value, parameter
 
*******************************************************************************/
void pin_messages(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
    T_pin_mess * mess_data = (T_pin_mess *)win_data->user;

	T_DISPLAY_DATA display_info;

//	T_MFW_SIM_PIN_STATUS status; //need to check the Pin 1 status  /* Warning Correction */
	//EF_SIMLCK simlck;MC, not needed SPR 1351
//	ULONG timcount = TIM_LOCK;   /* Warning Correction */
//	UBYTE i;        /* Warning Correction */

    T_pin * pin_data = (T_pin *)parameter;
	T_sim_rem * sim_rem_data = (T_sim_rem *)parameter;// sim_rem_data possible too

  TRACE_FUNCTION("Mmi.Pins:pin_messages");
  TRACE_EVENT_P1("Event: %d", event);

	dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, TxtNull, TxtNull, COLOUR_STATUS_PINS);

  /*
   * depending on signal
   */
  switch (event)
  {
	case PIN1_REQ_ATT:
	case PUK1_REQ_ACT_INFO:
	case PUK1_REQ_VER_INFO:
	case GSM_FAIL:
    case NEW_PIN_FAIL:
    case PIN_OK_INFO:
    case PUK1_UNBL_FAIL_INFO:
	case PUK1_UNBL_SUCC:
	case PUK1_UNBL_FATAL_ERROR:
	case SIM_UNLOCK_OK:
#ifdef SIM_PERS
	case SIM_LOCK_PERS_CHK_OK:
	case SMLK_SHOW_FC_FAIL:
	case SMLK_SHOW_FC_SUCC:
	//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		    case SMLK_SHOW_MK_FAIL:		//Event to show a dialog saying "Master Unlock Failed"
		    case SMLK_SHOW_MK_SUCC:		//Event to show a dialog saying "Master Unlock Success"
		    case SIM_LOCK_BUSY_UNBLOCK: //wrong unblock code
#endif		    
  case PIN1_STATUS:


	
		switch(event)
		{
	       case PIN1_REQ_ATT:
		      pin_data->pin_case = PIN1_REQ;
		      display_info.TextId = TxtPINFail;
	      display_info.TextId2 = 0;
			  if(pin_data->pin_retries EQ 1)
				display_info.TextId2 = TxtOneAttemptLeft;
			  else
				display_info.TextId2 = TxtTwoAttemptsLeft;
			  break;
  
		case PUK1_REQ_ACT_INFO:		      
			pin_data->pin_case = PUK1_REQ;
#ifdef SIM_PERS 
			if( C_KEY_REQ )
				display_info.TextId = TxtPhoneBlocked;
			else
#endif /*SIM_PERS */
		       	display_info.TextId = TxtSimBlocked;

			display_info.TextId2 = 0;
			display_info.TextString2 = 0;
			break;

		case PUK1_REQ_VER_INFO:
		      pin_data->pin_case = PUK1_REQ;
		      display_info.TextId =TxtPINBlock;
			  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
			  break;
		   case GSM_FAIL:
			  display_info.TextId = TxtNotAcc;
			  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
			  break;
		   case PUK1_UNBL_FATAL_ERROR:
			  pin_data->pin_case = PUK1_REQ;
		      display_info.TextId = TxtNotAcc;
			  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
			  break;
	   case NEW_PIN_FAIL:
		     pin_data->pin_case = INPUT_NEW_PIN;
		     display_info.TextId = TxtNewPIN;
		     display_info.TextId2 = TxtCodeInc;
			 display_info.TextString2 = 0;
			 break;
		   case PIN_OK_INFO:
		      pin_data->pin_case = PIN_OK;
			  display_info.TextId = TxtPINOK;
		  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
			  break;
			case PUK1_UNBL_FAIL_INFO:
			  pin_data->pin_case = PUK1_REQ;
			  display_info.TextId = TxtCodeInc;
	      display_info.TextId2 = TxtNull;
			  display_info.TextString2 = 0;
			  break;
			case PUK1_UNBL_SUCC:
			  pin_data->pin_case = PIN_OK;
			  display_info.TextId = TxtNewPIN;
		  display_info.TextId2 = TxtChanged;
			  display_info.TextString2 = 0;
			  break;
			case SIM_UNLOCK_OK:
			  pin_data->pin_case = PIN_OK;
			  display_info.TextId = TxtUnlockOK;
	      display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
			  break;
#ifdef SIM_PERS
			 case SIM_LOCK_PERS_CHK_OK:
			  pin_data->pin_case = PIN_OK;
			  display_info.TextId = TxtPhoneUnblocked;
	      display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
			  break;

			  case SMLK_SHOW_FC_FAIL:
			  {
				char buf1[20], buf2[20] ;
				int curr_fail_reset, curr_succ_reset;
				mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
//				if( curr_fail_reset )
				  	pin_data->pin_case = SMLK_PUK;
//				else
//					pin_data->pin_case = PERM_BLK;
				switch(mmi_simlock_aciErrDesc )
				{
					case CME_ERR_NetworkPersPinReq:
					case CME_ERR_NetworkSubsetPersPinReq:
					case CME_ERR_ProviderPersPinReq:
					case CME_ERR_CorporatePersPinReq:
					case CME_ERR_PhSimPinReq:
						sprintf((char*)buf1,"%d attempts left",curr_succ_reset);
						sprintf((char*)buf2,"%s", "FC Reset-Success");			
						break;

					default:
						sprintf((char*)buf1,"%d attempts left",curr_fail_reset);
						sprintf((char*)buf2,"%s", "FC Reset-Failure");								
						break;
				}
				display_info.TextString= buf1;
				display_info.TextString2 = buf2;
				  break;
			  }

			 case SMLK_SHOW_FC_SUCC:
			 {
				char buf1[20], buf2[20] ;
				int curr_fail_reset, curr_succ_reset;
				mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
				//if( curr_succ_reset )
				  	// leela: for simp: pin_data->pin_case = PIN_OK;
				//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
				//Changed the event from PIN_OK to SMLK_PUK bcoz after unblocking ME, 
				//for event PIN_OK it would go to idle screen without displaying menu for 
				//unlocking any categories if any
				  pin_data->pin_case = SMLK_PUK;
				//else
					//pin_data->pin_case = PERM_BLK;
				sprintf((char*)buf1,"%d attempts left",curr_succ_reset);
				sprintf((char*)buf2,"%s", "FC Reset-Success");								
				display_info.TextString= buf1;
				display_info.TextString2 = buf2;
				  break;
			 }

			//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
			//Event to display a dialog saying Master Unblock Failed
		    case SMLK_SHOW_MK_FAIL:
		    	{		    		
		    	  char buf[25];
		    	  pin_data->pin_case = SMLK_MASTERKEY;
			  sprintf((char*)buf,"%s", "Master Unlock Failed");
			  display_info.TextString= buf;
		  	  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
		    	}
		    	break;

			//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
			//Event to display a dialog saying Master Unblock Success		    	
		    case SMLK_SHOW_MK_SUCC:		
		    	{
		    	  char buf[25];
		    	  pin_data->pin_case = PIN_OK;
			  sprintf((char*)buf,"%s", "Master Unlock Success");
			  display_info.TextString= buf;
		  	  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
		    	}
		    	break;
 
			//x0pleela 13 Nov, 2006 DR: OMAPS00103356
			//Event to display a dialog saying Master Unblock Password is wrong
		    case SMLK_SHOW_WRONG_PWD:
		    	{		    		
		    	  char buf[25];
		    	  pin_data->pin_case = SMLK_MASTERKEY;
			  sprintf((char*)buf,"%s", "Incorrect Password");
			  display_info.TextString= buf;
		  	  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
		    	}
			
			//x0pleela 13 Nov, 2006 DR: OMAPS00103356
			//Event to display a dialog saying Master unlocking operation is successful
		    case SMLK_SHOW_DEP_CATS_UNLOCKED:
		    	{		    		
		    	  char buf[25];
		    	  pin_data->pin_case = SMLK_MASTERKEY;
			  sprintf((char*)buf,"%s", "Master Unlock Success");
			  display_info.TextString= buf;
		  	  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
		    	}
		    	break;
 
			//x0pleela 26 July, 2006 ER: OMAPS00087586, OMAPS00087587
			//Event to display a dialog saying Busy for wrong entry of unblocking password		    	
			case SIM_LOCK_BUSY_UNBLOCK: //wrong unblock code	
			{
				pin_data->pin_case = SMLK_PUK;
				display_info.TextId = TxtBusy;
			}
			break;
#endif			  
//nm insert new one
			case PIN1_STATUS:
			  pin_data->pin_case = PIN1_STATUS;

			  if(pin_data->set_state EQ ENABLE)
			  {
				display_info.TextId = TxtEnabled;
		      }
			  else
			  {
				display_info.TextId = TxtDisabled;
			  }

		      display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
			  break;
//NM
	  
		}

		dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)pin_info_cb, THREE_SECS, 0 );
		display_info.Identifier = pin_data->pin_case;
		info_dialog(pin_data->pin_win,&display_info); //information screen
		pin_mess_destroy(mess_data->pin_mess_win);
#ifdef SIM_PERS		
		//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		//Delete the simp_list window handler  after displaying the dialog
		if(pin_data->simp_list_win)
			win_delete(pin_data->simp_list_win);
#endif
		break;
	case SIM_LOCK_ERR:
		display_info.TextId = TxtCodeInc;
		display_info.TextId2 = TxtPleaseWait;
		display_info.Identifier = pin_data->pin_case;//last pin_case

		dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)pin_info_cb, 5*TIM_LOCK_JUMP, 0 );
		pin_mess_destroy(mess_data->pin_mess_win);
		info_dialog(pin_data->pin_win,&display_info); //information screen
		break;

	case SIM_REMOVED:
		pin_data->display_id1 = TxtNoCard;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(sim_rem_data->sim_rem_win,TXT_INSERT_CARD,0,pin_data);
		break;
	case INVALID_CARD:
		pin_data->display_id1 = TxtInvalidCard;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_INVALID_CARD,0,pin_data);
		break;
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS			
//x0pleela 30 Aug, 2006 DR: OMAPS00091250
	case NO_MEPD:
		pin_data->display_id1 = TxtNoMEPD;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_NO_MEPD,0,pin_data);
		break;		
#endif		
	case NO_SIM_CARD:
		pin_data->display_id1 = TxtNoCard;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_NO_CARD,0,pin_data);
		break;
// Nov 24, 2005, a0876501, DR: OMAPS00045909
	case INVALID_IMEI:
		pin_data->display_id1 = TxtInvalidIMEI;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_INVALID_IMEI,0,pin_data);
		break;
	case SIM_LOCK_ALL:
		pin_data->display_id1 = TxtBlckPerm;
		pin_data->display_id2 = TxtDealer;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_SIM_LOCK_ALL,0,pin_data);
		break;
	case SIM_PLOCK_REQ:
		pin_data->display_id1 = TxtEnterPCK;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_SIM_PLOCK,0,pin_data);
		break;
	case SIM_NLOCK_REQ:
		pin_data->display_id1 = TxtEnterNCK;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_SIM_NLOCK,0,pin_data);
		break;
	case SIM_CLOCK_REQ:
		pin_data->display_id1 = TxtEnterCCK;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_SIM_CLOCK,0,pin_data);
		break;
	case SIM_NSLOCK_REQ:
		pin_data->display_id1 = TxtEnterNSCK;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_SIM_NSLOCK,0,pin_data);
		break;
	case SIM_SPLOCK_REQ:
		pin_data->display_id1 = TxtEnterSPCK;
		pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_SIM_SPLOCK,0,pin_data);
		break;
	default:
		break;
  }
}


#ifndef NEW_EDITOR
/*******************************************************************************

 $Function:	pin_icons 
 $Description:	display back from pins
 $Returns:		none
 $Arguments:	none
 
*******************************************************************************/
static void pin_icons(void)
{

	TRACE_FUNCTION("pin_icons");


	// clear the softkeys
	TRACE_FUNCTION("clear softkey 8");
	pin_skClear();

	TRACE_FUNCTION("dsplClearAll 6");
	dspl_ClearAll();

	GlobalIconStatus = GlobalSignalIconFlag | GlobalBatteryIconFlag |
		       GlobalVoiceMailIconFlag 
		      | GlobalCallForwardingIconFlag| GlobalKeyplockIconFlag
					  | GlobalRingerIconFlag | GlobalRingVibrIconFlag
					  | GlobalVibratorIconFlag | GlobalAlarmIconFlag
					  | GlobalSilentRingerIconFlag
			#ifdef FF_MMI_CPHS
					  | GlobalRoamingIndFlag
			#endif

/* x0045876, 14-Aug-2006 (WR - nested comment is not allowed) */
/* SH 18/01/02. Flag for GPRS icon. */
			
/* SH 18/01/02. Flag for GPRS icon.
   Note: SPR877 - Homezone icon not displayed in PIN screen. */
				#ifdef MMI_GPRS_ENABLED
					  | GlobalGPRSOnIconFlag
				#endif
				;
	iconsShow();		/* representation of the desired icons */
}

#endif

/*******************************************************************************

 $Function:	clearEditArray 
 $Description:	clear EditArray
 $Returns:		none
 $Arguments:	pin editor attributes
*******************************************************************************/
static void clear_edit_array (void * parameter)
{
//	U8 i;     /* Warning Correction */
	T_pin_edt * edt_data = (T_pin_edt *)parameter;

	TRACE_FUNCTION("MmiPins:clearEditArray");

	/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
	memset(edt_data->edtbuf,'\0',sizeof(edt_data->edtbuf));
	ATB_edit_Reset(edt_data->editor);
	ATB_edit_Unhide(edt_data->editor);
#else /* NEW_EDITOR */
	memset(edt_data->edtbuf,'\0',sizeof(edt_data->edtbuf));
	edtReset(edt_data->editor_handle);
	edtUnhide(edt_data->editor_handle);
#endif

}


/*******************************************************************************

 $Function:	pinsIsFocussed
 $Description:	check MmiPins windows focussed
 $Returns:		Status int
 $Arguments:	none
*******************************************************************************/

int pinsIsFocussed(void)
{
	int status;

	if (winIsFocussed(pin_windows) || winIsFocussed(pin_edit_windows) ||
		winIsFocussed(pin_editor_window) ||winIsFocussed(pin_mess_windows))
		status = FOCUSSED_PINS;
	else
		status = NOT_FOCUSSED_PINS;

	return status;
}


/*******************************************************************************

 $Function:	pinsSetIsFocussed
 $Description:	check MmiPins in settings windows focussed
 $Returns:		Status int
 $Arguments:	none
*******************************************************************************/
int pinsSetIsFocussed(void)
{
	int status;

	if (winIsFocussed(set_pin_windows))
		status = FOCUSSED_PINS;
	else
		status = NOT_FOCUSSED_PINS;

	return status;
}


/*******************************************************************************

 $Function:	emerg_pin
 $Description:	emergency call
 $Returns:		none
 $Arguments:	pin editor attributes
*******************************************************************************/
static void emerg_pin(void * string)
{
	T_pin_edt * edt_data = (T_pin_edt *)string;

	edt_data->emergency_call = FALSE;
	clear_edit_array(edt_data);	      /*   clear editor array	*/
	callNumber((UBYTE*)edt_data->pin);	   /* emergency call	*/
	memset(edt_data->pin, '\0', sizeof(edt_data->pin));/*initial string*/
	edt_data->editor_index = 0;
TRACE_FUNCTION("clear softkey 9"); 
	pin_skClear();
}



/*******************************************************************************

 $Function:	pin_info_cb
 $Description:	pin information screen call back
 $Returns:		none
 $Arguments:	win, identifier, reason for callback (not used)
*******************************************************************************/
int pin_info_cb(T_MFW_HND win, USHORT identifier, UBYTE reasons)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user;

    TRACE_EVENT_P1 ("pin_info_cb() %d", identifier);

	switch(identifier)
	{
		case PIN_OK:
		{
#ifdef SIM_PERS
			int curr_fail_reset1, curr_succ_reset1;
#endif
			TRACE_FUNCTION("pin_info_cb: PIN_OK");

#ifdef SIM_PERS
			mfw_simlock_check_status(0, &curr_fail_reset1, &curr_succ_reset1);

			if (curr_succ_reset1 == 0)
			{
				perm_blocked =1;
				SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
			}		
			else
#endif
				SEND_EVENT(pin_data->pin_win,PIN_OK_END,0,NULL);//PIN was needed
		}
			break;
	
		case PIN1_REQ:
		//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		//case PUK1_REQ:		//Handling PUK1_REQ separately as a menu should be displayed for Unblocking ME and Master Unlock
		case INPUT_NEW_PIN:
			
			SEND_EVENT(pin_data->pin_win,identifier,0,NULL);//pin_main data !!
			break;


			case PUK1_REQ:
#ifdef SIM_PERS
				//x0pleela 26 Sep, 2006 DR: OMAPS00096565
				//Adding a check for C_KEY_REQ. If set, displaySIMP menu
				//Else prompt the user for PUK entry
				if( C_KEY_REQ ) 
				{
				//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
				//Handling PUK1_REQ separately as a menu should be displayed for Unblocking ME and Master Unlock
				  if( simlock_get_masterkey_status())
				  {
				  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
				  }
				}
				  else
#endif
			  SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,NULL);//pin_main data !!
			break;
#ifdef SIM_PERS
		//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		//Handling SMLK_MASTERKEYto display menu for Unblocking ME or unlocking categories if any and Master Unlock
		case SMLK_MASTERKEY:
			//x0pleela 25 Sep, 2006 ER: OMAPS00095524	
			//check for CME class and handle all CME errors
			if( ((mmi_simlock_aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Cme) 	
			{
			switch(mmi_simlock_aciErrDesc & 0x0000FFFF)
			{
				case CME_ERR_NetworkPersPinReq:
					TRACE_EVENT("CME_ERR_NetworkPersPinReq");
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_NLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
							SEND_EVENT(pin_data->pin_win,INPUT_NLOCK_PIN_REQ,0,pin_data);
						break;
						
					case CME_ERR_NetworkSubsetPersPinReq:
						TRACE_EVENT("CME_ERR_NetworkSubsetPersPinReq");
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_NSLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
							SEND_EVENT(pin_data->pin_win,INPUT_NSLOCK_PIN_REQ,0,pin_data);
						break;
						
					case CME_ERR_ProviderPersPinReq:
						TRACE_EVENT("CME_ERR_ProviderPersPinReq");
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_SPLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
							SEND_EVENT(pin_data->pin_win,INPUT_SPLOCK_PIN_REQ,0,pin_data);
						break;
						
					case CME_ERR_CorporatePersPinReq:
						TRACE_EVENT("CME_ERR_CorporatePersPinReq");
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_CLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
							SEND_EVENT(pin_data->pin_win,INPUT_CLOCK_PIN_REQ,0,pin_data);
						break;
						
					case CME_ERR_PhSimPinReq:
						TRACE_EVENT("CME_ERR_PhSimPinReq");
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_PLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
							SEND_EVENT(pin_data->pin_win,INPUT_SIM_PIN_REQ,0,pin_data);
						break;

					case CME_ERR_PhoneFail:
					case CME_ERR_NetworkPersPukReq:
					case CME_ERR_NetworkSubsetPersPukReq:
					case CME_ERR_ProviderPersPukReq:
					case CME_ERR_CorporatePersPukReq:
					case CME_ERR_WrongPasswd:
				
						TRACE_FUNCTION("PUK Req");
						C_KEY_REQ = 1;
						  if( simlock_get_masterkey_status())
						  {
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						{							
							SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
						}
						break;	
						
					default:
						TRACE_EVENT("Undefined error");
						break;
		    			}
				}
				//x0pleela 25 Sep, 2006 ER: OMAPS00095524	
				//check for Ext class and handle all Extension errors
				else if( ((mmi_simlock_aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext)
				{
					switch(mmi_simlock_aciErrDesc & 0x0000FFFF)
					{
						//Request for Blocked Network Password
						case EXT_ERR_BlockedNetworkPersPinReq:
							TRACE_EVENT("EXT_ERR_BlockedNetworkPersPinReq");
							  if( simlock_get_masterkey_status())
							  {
							  	mmi_simlock_locktype = MFW_SIM_PBLOCK;
							  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
							  }
							  else
								SEND_EVENT(pin_data->pin_win,INPUT_PBLOCK_PIN_REQ,0,pin_data);
						break;

						//Request for Blocked Network Unblock code 
						case EXT_ERR_BlockedNetworkPersPukReq:
							TRACE_EVENT("PUK Req");
							C_KEY_REQ = 1;
							  if( simlock_get_masterkey_status())
							  {
							  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
							  }
							  else
							{							
								SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
							}
						break;	

						default:
							break;
					}
				}
				break;

		case SMLK_PUK:
		{
			int status1,curr_fail_reset1, curr_succ_reset1;

			status1 = mfw_simlock_check_status(0, &curr_fail_reset1, &curr_succ_reset1);

			if (status1 == MFW_SIM_PERM_BLOCKED)
			{
				perm_blocked =1;
				SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
			}
			else
			{
				//x0pleela 11 Sep, 2006  DR: OMASP00094215
				//checking for Class type and the ext busy error
				if( ( ((mmi_simlock_aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext) AND
					(mmi_simlock_aciErrDesc & 0x0000FFFF) EQ EXT_ERR_Busy)
				{
					C_KEY_REQ = 1;
						  if( simlock_get_masterkey_status())
						  {
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						{							
							SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
						}
				}
				//x0pleela 25 Sep, 2006 ER: OMAPS00095524	
    				//check for Cme class and handle all CME errors
				else if( ((mmi_simlock_aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Cme)
				{
				//end of x0pleela 11 Sep, 2006  DR: OMASP00094215
			   	switch(mmi_simlock_aciErrDesc & 0x0000FFFF)
				{
					case CME_ERR_NetworkPersPinReq:
						TRACE_EVENT("CME_ERR_NetworkPersPinReq");
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//Displays menu for Unblocking ME or unlocking categories if any and Master Unlock
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_NLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						    SEND_EVENT(pin_data->pin_win,INPUT_NLOCK_PIN_REQ,0,pin_data);
						break;
						
					case CME_ERR_NetworkSubsetPersPinReq:
						TRACE_EVENT("CME_ERR_NetworkSubsetPersPinReq");
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//Displays menu for Unblocking ME or unlocking categories if any and Master Unlock
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_NSLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						    SEND_EVENT(pin_data->pin_win,INPUT_NSLOCK_PIN_REQ,0,pin_data);
						break;
						
					case CME_ERR_ProviderPersPinReq:
						TRACE_EVENT("CME_ERR_ProviderPersPinReq");
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//Displays menu for Unblocking ME or unlocking categories if any and Master Unlock
					       if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_SPLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						    SEND_EVENT(pin_data->pin_win,INPUT_SPLOCK_PIN_REQ,0,pin_data);
						break;
						
					case CME_ERR_CorporatePersPinReq:
						TRACE_EVENT("CME_ERR_CorporatePersPinReq");
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//Displays menu for Unblocking ME or unlocking categories if any and Master Unlock				  
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_CLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						SEND_EVENT(pin_data->pin_win,INPUT_CLOCK_PIN_REQ,0,pin_data);
						break;
						
					case CME_ERR_PhSimPinReq:
						TRACE_EVENT("CME_ERR_PhSimPinReq");
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//Displays menu for Unblocking ME or unlocking categories if any and Master Unlock					  
						  if( simlock_get_masterkey_status())
						  {
						  	mmi_simlock_locktype = MFW_SIM_PLOCK;
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
						SEND_EVENT(pin_data->pin_win,INPUT_SIM_PIN_REQ,0,pin_data);
						break;

					case CME_ERR_PhoneFail:
					case CME_ERR_NetworkPersPukReq:
					case CME_ERR_NetworkSubsetPersPukReq:
					case CME_ERR_ProviderPersPukReq:
					case CME_ERR_CorporatePersPukReq:
					case CME_ERR_WrongPasswd:
									
							TRACE_FUNCTION("PUK Req");
						C_KEY_REQ = 1;
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//Displays menu for Unblocking ME or unlocking categories if any and Master Unlock
						  if( simlock_get_masterkey_status())
						  {
						  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
						  }
						  else
								SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
						break;	
						
					default:
						TRACE_EVENT("Undefined error");
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						//If no CME error, which implies none of the categories are locked
						//so send PIN_OK_END event for camping on to the network
						SEND_EVENT(pin_data->pin_win,PIN_OK_END,0,NULL);//PIN was needed
						break;
		    			}
				//x0pleela 11 Sep, 2006  DR: OMASP00094215
				}
				//end of x0pleela 11 Sep, 2006  DR: OMASP00094215

				    //x0pleela 25 Sep, 2006 ER: OMAPS00095524	
				    //check for Ext class and handle all Extension errors
				else if( ((mmi_simlock_aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext)
				{
					switch(mmi_simlock_aciErrDesc & 0x0000FFFF)
					{
						//Request for Blocked Network Password
						case EXT_ERR_BlockedNetworkPersPinReq:
							TRACE_EVENT("EXT_ERR_BlockedNetworkPersPinReq");
							//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
							//Displays menu for Unblocking ME or unlocking categories if any and Master Unlock
							if( simlock_get_masterkey_status())
							{
								mmi_simlock_locktype = MFW_SIM_PBLOCK;
								pin_data->simp_list_win = mmi_simlock_category_menus(win);
							}
							else
								SEND_EVENT(pin_data->pin_win,INPUT_PBLOCK_PIN_REQ,0,pin_data);
							break;

						//Request for Blocked Network Unblock code 
						case EXT_ERR_BlockedNetworkPersPukReq:
							TRACE_EVENT("PUK Req");
							C_KEY_REQ = 1;
							//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
							//Displays menu for Unblocking ME or unlocking categories if any and Master Unlock
							if( simlock_get_masterkey_status())
							{
								pin_data->simp_list_win = mmi_simlock_category_menus(win);
							}
							else
							{							
								SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
							}
							break;	

						default:
							break;
					}
				}
			}
		}
		break;
#endif

		case INPUT_PIN1:
			SEND_EVENT(pin_data->pin_win,PIN1_REQ,0,NULL);//pin_main data !!
			break;
		case INPUT_PUK1:
			TRACE_FUNCTION("INPUT_PUK1");
			SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,NULL);//pin_main data !!
			break;
		/*mc SPR 1351, check if simlocks blocked before requesting them again*/
		case SIM_PLOCK:
			if (sim_check_sim_Plock() != MFW_SIM_BLOCKED)
				SEND_EVENT(pin_data->pin_win,SIM_PLOCK_REQ,0,NULL);//pin_main data !!
			else
			{	ShowMessage(idle_get_window(), TxtBlckPerm, TxtDealer);
				pin_destroy(pin_data->pin_win);
			}
			break;
		case SIM_NLOCK:
			if (sim_check_sim_Nlock() != MFW_SIM_BLOCKED)
				SEND_EVENT(pin_data->pin_win,SIM_NLOCK_REQ,0,NULL);//pin_main data !!
			else
			{	ShowMessage(idle_get_window(), TxtBlckPerm, TxtDealer);
				pin_destroy(pin_data->pin_win);
			}
			break;
		case SIM_SPLOCK:
			if (sim_check_sim_SPlock() != MFW_SIM_BLOCKED)
				SEND_EVENT(pin_data->pin_win,SIM_SPLOCK_REQ,0,NULL);//pin_main data !!
			else
			{	ShowMessage(idle_get_window(), TxtBlckPerm, TxtDealer);
				pin_destroy(pin_data->pin_win);
			}
			break;
		case SIM_NSLOCK:
			if (sim_check_sim_NSlock() != MFW_SIM_BLOCKED)
				SEND_EVENT(pin_data->pin_win,SIM_NSLOCK_REQ,0,NULL);//pin_main data !!
			else
			{	ShowMessage(idle_get_window(), TxtBlckPerm, TxtDealer);
				pin_destroy(pin_data->pin_win);
			}
		    break;
		case SIM_CLOCK:
			if (sim_check_sim_Clock() != MFW_SIM_BLOCKED)
				SEND_EVENT(pin_data->pin_win,SIM_CLOCK_REQ,0,NULL);//pin_main data !!
			else
			{	ShowMessage(idle_get_window(), TxtBlckPerm, TxtDealer);
				pin_destroy(pin_data->pin_win);
			}
			break;
			/*MC end*/
		case PIN1_STATUS:
				SEND_EVENT(pin_data->pin_win,PIN1_STATUS_END,0,NULL);//pin_main data !!
			break;
		default:
			break;
	}
	return 1;
}

/*******************************************************************************

 $Function:	sim_rem_init
 $Description:	This is the start-up time initialisation routine.
		For compatibility reasons the functions is still there.
 $Returns:		none
 $Arguments:	parent window
*******************************************************************************/
void sim_rem_init (T_MFW_HND parent_window)
{
  sim_rem_create (parent_window);
}




/*******************************************************************************

 $Function:	sim_rem_exit
 $Description:	his is the shutdown time clean-up routine.
 $Returns:		none
 $Arguments:	parent window
*******************************************************************************/
void sim_rem_exit(T_MFW_HND parentWindow)
{
  sim_rem_destroy (sim_rem_data.sim_rem_win);
}



/*******************************************************************************

 $Function:	sim_rem_create 
 $Description:	Creation of an instance for the SIM remove dialog.
				Type of dialog : SINGLE_STATIC
				Top Window must be available at any time, only one instance.
 $Returns:		window
 $Arguments:	parent window
*******************************************************************************/
T_MFW_HND sim_rem_create (T_MFW_HND parent_window)
{

  T_sim_rem * data = &sim_rem_data;
  T_MFW_WIN  * win;

  data->sim_rem_win = win_create (parent_window, 0,	MfwWinVisible, (T_MFW_CB)sim_rem_win_cb);

  if (data->sim_rem_win EQ 0)
    return 0;
  else
  {
	  /*
	   * Create window handler
	   */
	  data->mmi_control.dialog    = (T_DIALOG_FUNC)sim_rem_main;
	  data->mmi_control.data      = data;
	  data->parent_win = parent_window;
	  win			      = ((T_MFW_HDR *)data->sim_rem_win)->data;
	  win->user		      = (void *) data;

	  /*
	   * Create any other handler
	   */

	  data->sim_handle = sim_create(0,E_SIM_ALL_SERVICES,(MfwCb)sim_rem_cb_main);
	  winShow(data->sim_rem_win);
	  /*
	   * return window handle
	   */
	  return data->sim_rem_win;
  }
}



/*******************************************************************************

 $Function:	sim_rem_destroy 
 $Description:	Destroy the sim remove dialog.
 $Returns:		none
 $Arguments:	window
*******************************************************************************/
void sim_rem_destroy (T_MFW_HND own_window)
{
  T_sim_rem  * data;
  T_MFW_WIN * win;

  if (own_window)
  {
	 win = ((T_MFW_HDR *)own_window)->data;
     data = (T_sim_rem *)win->user;

	 if(data)
	 {
      /*
       * Exit SIM and Delete SIM Handler
       */
       sim_delete (data->sim_handle);

      /*
       * Delete WIN Handler
       */
      win_delete (data->sim_rem_win);
	 }
  }
}


/*******************************************************************************

 $Function:	sim_rem_win_cb	
 $Description:	Callback function for windows
 $Returns:		Status int
 $Arguments:	event, window
*******************************************************************************/
static int sim_rem_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
  if (event EQ MfwWinVisible)
  {
    /*
     * Top Window has no output
     */
	TRACE_FUNCTION("dsplClearAll 7");	   
    dspl_ClearAll();
	return 1;
  }
  return 0;
}



/*******************************************************************************

 $Function:	sim_rem_cb_main 
 $Description:	SIM remove handler
 $Returns:		Status int
 $Arguments:	event, sim status
*******************************************************************************/
int sim_rem_cb_main (T_MFW_EVENT event, T_MFW_HND para)
{

	T_MFW_SIM_STATUS * status;

	T_MFW_HND sim_rem_win;

    status = (T_MFW_SIM_STATUS *)para;
	TRACE_FUNCTION("MmiPins:sim_rem_cb_main");

    switch(event)
	{
	    case E_SIM_STATUS:
		  /*
		   * check whether decoded message is available
		   */
			if( para EQ (T_MFW_SIM_STATUS *)NULL )
				return MFW_RES_ILL_HND;

			status = (T_MFW_SIM_STATUS *)para;
			 switch (status->sim_procedure)
			 {
				case MFW_SIM_REMOVED:
					switch (status->sim_status)
					{
				/*
				 *  SIM card is removed
				 */
						case MFW_SIM_NO_SIM_CARD:
							TRACE_FUNCTION("sim_rem_cb_main:SIM removed");
							sim_rem_win = sim_rem_create(0);
							if(sim_rem_win)
							{
								SEND_EVENT(sim_rem_win,SIM_REMOVED,0,NULL);
							}
				/*
				 * limited shall be the requested service
				 * if no service is reached, the limited
				 * service is requested*/
						nm_registration (NM_AUTOMATIC, 0, TRUE);
							break;
						default:
							return 0;
					}
				break;
				default:
					return 0;
			 }
		 return 1;
	}
	
	/* x0045876, 14-Aug-2006 (WR - missing return statement at end of non-void function ) */
	return 0;
}



/*******************************************************************************

 $Function:	sim_rem_main 
 $Description:	SIM remove main Dialog Handling function
 $Returns:		None
 $Arguments:	window, event, value, parameter
*******************************************************************************/
static void sim_rem_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_sim_rem * sim_rem_data = (T_sim_rem *)win_data->user;//sim remove main data
//	T_pin_mess * mess_data = (T_pin_mess *) parameter;//pin message data  /* Warning Correction */

	T_MFW_HND pin_mess_win;
	T_MFW_HND pin_edt_win;

	TRACE_FUNCTION("MmiPins:sim_rem_main");

  switch(event)
  {
	  case SIM_REMOVED:					      //Text "Insert Card "
		   pin_mess_win = pin_mess_create(sim_rem_data->sim_rem_win);
		   if(pin_mess_win)
		   {
				SEND_EVENT(pin_mess_win,event,0,sim_rem_data);
		   }
		   break;
      case TXT_INSERT_CARD:
			sim_rem_data->pin_case = INSERT_CARD;
		    pin_edt_win = pin_edt_create(sim_rem_data->sim_rem_win);// Start: enter only emerg call
			if(pin_edt_win)
			{
			    SEND_EVENT(pin_edt_win,INSERT_CARD,0,sim_rem_data);
			}
			break;
	  default:
		  break;
  }

}




/*******************************************************************************

 $Function:	setting_pin_init 
 $Description:	This is the start-up time initialisation routine.
		Start in the Menu
 $Returns:		None
 $Arguments:	parent window
*******************************************************************************/
void setting_pin_init (T_MFW_HND parent_window)
{
  setting_pin_create (parent_window);
}



/*******************************************************************************

 $Function:	setting_pin_create
 $Description:	Creation of an instance for the Settings PIN main dialog.
				Type of dialog : SINGLE_DYNAMIC
				Top Window must be available at any time, only one instance.
 $Returns:		window
 $Arguments:	parent window
*******************************************************************************/
T_MFW_HND setting_pin_create (T_MFW_HND parent_window)
{

  T_pin * data = (T_pin *)ALLOC_MEMORY (sizeof (T_pin));
  T_MFW_WIN	* win;

  data->pin_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)setting_pin_win_cb);

  TRACE_FUNCTION("MmiPins:setting_pin_create");

  set_pin_windows = data->pin_win;

  if (data->pin_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  data->mmi_control.dialog    = (T_DIALOG_FUNC)setting_pin_main;
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_win)->data;
  win->user		      = (void *) data;

  /*
   * Create any other handler
   */

  data->sim_handle = sim_create(data->pin_win,E_SIM_ALL_SERVICES,(MfwCb)sim_event_cb_setting);

  /*
   * Initialise
   */
 data->set_state = DEFAULT;
 data->puk_request = FALSE;


  mfwSetSignallingMethod(1);//mfw focus handling
  winShow(data->pin_win);//focus on settings:PIN/PIN2 Change/act/Deac


  /*
   * return window handle
   */
  return data->pin_win;
}


/*******************************************************************************

 $Function:	setting_pin_destroy 
 $Description:	Destroy the settings pin main dialog.
 $Returns:		none
 $Arguments:	window
*******************************************************************************/
void setting_pin_destroy  (T_MFW_HND own_window)
{
  T_pin * data;
  T_MFW_WIN * win;

  if (own_window)
  {
	 TRACE_FUNCTION("MmiPins:setting_pin_destroy");

	 win = ((T_MFW_HDR *)own_window)->data;
     data = (T_pin *)win->user;

	 if(data)
	 {
      /*
       * Exit SIM and Delete SIM Handler
       */
	 sim_delete (data->sim_handle);

      /*
       * Delete WIN Handler
       */
	  set_pin_windows = 0;
      win_delete (data->pin_win);
      data->pin_win=0;
	if(data)
	 FREE_MEMORY((void *)data,(sizeof(T_pin)));
	 }
  }
}


/*******************************************************************************

 $Function:	setting_pin_win_cb 
 $Description:	Callback function for main windows in settings
 $Returns:		Status int
 $Arguments:	event, window
*******************************************************************************/
static int setting_pin_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
  TRACE_FUNCTION("setting_pin_win_cb");
  if (event EQ MfwWinVisible)
  {
    /*
     * Top Window has no output
     */
	/* NDH : Removed to prevent Blue Screen on Pin Entry */
	return 1;
  }
  return 0;

}


/*******************************************************************************

 $Function:	sim_event_cb_setting 
 $Description:	SIM event handler for Setttings Pins
 $Returns:		Status int
 $Arguments:	event, sim status
*******************************************************************************/
int sim_event_cb_setting (T_MFW_EVENT event, T_MFW_HND para)
{

	T_MFW_SIM_STATUS * status;

    T_MFW_HND win = mfw_parent(mfw_header());


	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user;

	status = (T_MFW_SIM_STATUS *)para;

	TRACE_FUNCTION("Sim Event Handler of Settings Pin"); 
 switch(event)
 {
	case E_SIM_INSERTED://handle in sim_rem_cb_main
	    return 0;
	case E_SIM_STATUS:
	  /*
	   * check whether decoded message is available
	   */
		if( para EQ (T_MFW_SIM_STATUS *)NULL )
		   return MFW_RES_ILL_HND;

		status = (T_MFW_SIM_STATUS *)para;
		 switch (status->sim_procedure)
		 {
		/*
		 * Initial activation of the SIM card
		 */
			case MFW_SIM_VERIFY:
			//xrashmic 1 Jul, 2006 OMAPS00075784
			//When pin is blocked, the user is immediatly prompted with puk 
			// entry screen or else the blue screen is displayed
			case MFW_SIM_ACTIVATION:
		  /*
		   * check the result of verify
		   */
			  switch (status->sim_status)
			  {
			/*
			 * PIN 1 must be entered
			 */
					case MFW_SIM_PIN_REQ:
					if(status->sim_pin_retries < PIN_ENTRY_MAX)
					{
							TRACE_FUNCTION("sim_event_cb_settings V:PIN1 req-retr");
							pin_data->pin_retries = status->sim_pin_retries;
							SEND_EVENT(pin_data->pin_win,PIN1_REQ_ATT,0,pin_data);
					}
					else
					{
							TRACE_FUNCTION("sim_event_cb_setting V:PIN1 req");
							SEND_EVENT(pin_data->pin_win,PIN1_REQ_OLD,0,pin_data);
					}
					break;
			/*
			 * PIN 2 must be entered
			 */
					case MFW_SIM_PIN2_REQ:
					if(status->sim_pin_retries < PIN_ENTRY_MAX)
					{
							TRACE_FUNCTION("sim_event_cb_settings V:PIN2 req-retr");
							pin_data->pin_retries = status->sim_pin_retries;
							SEND_EVENT(pin_data->pin_win,PIN2_REQ_ATT,0,pin_data);
					}
					else
					{
							TRACE_FUNCTION("sim_event_cb_setting V:PIN2 req");
							SEND_EVENT(pin_data->pin_win,PIN2_REQ,0,pin_data);
					}
					break;
			/*
			 * SIM card is blocked, PUK 1 is needed
			 */
					case MFW_SIM_PUK_REQ:
						pin_data->puk_request = TRUE;
						TRACE_FUNCTION("sim_event_cb_setting V:PUK1 req");
						SEND_EVENT(pin_data->pin_win,PUK1_REQ_VER_INFO,0,pin_data);
						break;
			/*
			 * SIM card is blocked, PUK 2 is needed
			 */
					case MFW_SIM_PUK2_REQ:
						pin_data->puk_request = TRUE;
						TRACE_FUNCTION("sim_event_cb_setting V:PUK2 req");
						SEND_EVENT(pin_data->pin_win,PUK1_REQ_VER_INFO,0,pin_data);
						break;

			/*
			 * PIN entering successfull
			 */
					case MFW_SIM_NO_PIN:
						TRACE_FUNCTION("sim_event_cb_setting V:PIN ok ");
						pin_data->pin_case = PIN_OK_INFO;
						SEND_EVENT(pin_data->pin_win,PIN_OK_INFO,0,pin_data);
						break;

                    /* Marcus: Issue 1609: 23/01/2003: Start */
                    case MFW_SIM_FAILURE:
                        /* An attempt to verify a PIN has failed */
                        if (status->sim_status_type == MFW_SIM_PIN2)
                        {
                            /* PIN2 verification not supported by this SIM */
                            SEND_EVENT(pin_data->pin_win,PIN2_SIM_FAILURE,0,pin_data);
                        }
                        else /* Not verifying PIN2, presumably verifying PIN1 */
                            return 0;
                        break;
                    /* Marcus: Issue 1609: 23/01/2003: End */
                    
					default:
						return 0;
			  }
			break;
			/*
			 * response to PUK entering
			 */
			case MFW_SIM_UNBLOCK:
			  switch (status->sim_status)
			  {
				case MFW_SIM_PUK_REQ:
					TRACE_FUNCTION("sim_event_cb_setting:unblock failure");
					SEND_EVENT(pin_data->pin_win,PUK1_UNBL_FAIL_INFO,0,pin_data);
					break;
				case MFW_SIM_PUK2_REQ:
					TRACE_FUNCTION("sim_event_cb_setting:unblock failure");
					SEND_EVENT(pin_data->pin_win,PUK1_UNBL_FAIL_INFO,0,pin_data);
					break;
				case MFW_SIM_SUCCESS:
					TRACE_FUNCTION("sim_event_cb_setting:unblock success");
					SEND_EVENT(pin_data->pin_win,PUK1_UNBL_SUCC,0,pin_data);
					break;
				case MFW_SIM_FAILURE:
					TRACE_FUNCTION("sim_event_cb_setting:unblock fatal error");
					SEND_EVENT(pin_data->pin_win,PUK1_UNBL_FATAL_ERROR,0,pin_data);
					break;				
				case MFW_SIM_INVALID_CARD:
					TRACE_FUNCTION("sim_event_cb_main:unblock failed, no more retries");
					SEND_EVENT(pin_data->pin_win,INVALID_CARD,0,pin_data);
					break;
				default:
					return 0;
			  }
			break;

			case MFW_SIM_REMOVED:
				return 0;/* there not handled  */
			case MFW_SIM_CHANGE:
			 switch (status->sim_status)
			 {
				case MFW_SIM_SUCCESS:
					TRACE_FUNCTION("sim_event_cb_setting: succ/CH");
					if(pin_data->set_state EQ IDLE_GSM)
					{
						SEND_EVENT(pin_data->pin_win,PIN1_CH_SUCC,0,pin_data);/* change PIN by	gsm string in idle */
					}
					else if(pin_data->pin_case EQ INPUT_NEW_PIN_AGAIN OR (status->sim_status_type EQ MFW_SIM_PIN1))
					{
						SEND_EVENT(pin_data->pin_win,PIN1_CH_SUCC,0,pin_data);/* change PIN, also by gsm string */
					}
					else
					{
						SEND_EVENT(pin_data->pin_win,PIN2_CH_SUCC,0,pin_data);/* change PIN2, also by gsm string */
					}
					break;
				case MFW_SIM_FAILURE:
					TRACE_FUNCTION("sim_event_cb_setting: fail/CH");
					if(!pin_data->puk_request)
					{
						if(pin_data->pin_case EQ INPUT_NEW_PIN_AGAIN)
						{
							SEND_EVENT(pin_data->pin_win,NEW_PIN_FAIL,0,pin_data);/* new Pin failed */
						}
						else if(pin_data->pin_case EQ INPUT_NEW_PIN2_AGAIN)
						{
							SEND_EVENT(pin_data->pin_win,NEW_PIN2_FAIL,0,pin_data);/* new Pin2 failed */
						}
						else if(pin_data->gsm_state)
						{
							if(sim_pin_count(MFW_SIM_PIN1) <= 0 )//  May 13, 2004        REF: CRR 13632  xvilliva
							{
								pin_data->puk_request = TRUE;
								SEND_EVENT(pin_data->pin_win,PUK1_REQ_VER_INFO,0,pin_data);
							}
							else
							SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,pin_data);
						}
					 }
					else
					{
						if(pin_data->pin_case EQ INPUT_NEW_PIN_AGAIN)
						{
							SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
						}
						else
						{
							SEND_EVENT(pin_data->pin_win,PUK2_REQ,0,pin_data);
						}

					}
				break;
			 default:
				return 0;
			}
			break;
		    case MFW_SIM_DISABLE:
		    case MFW_SIM_ENABLE:
		   switch (status->sim_status)
			   {
			     case MFW_SIM_SUCCESS:
		    TRACE_FUNCTION("sim_event_cb_setting: succ/DIS/E");

		    if (status->sim_procedure EQ MFW_SIM_ENABLE)
					{
					  SEND_EVENT(pin_data->pin_win,PIN1_ENAB_END,0,pin_data);
					}
				    else
					{
					  SEND_EVENT(pin_data->pin_win,PIN1_DISAB_END,0,pin_data);
					}
				  break;
			     case MFW_SIM_FAILURE:
				    TRACE_FUNCTION("sim_event_cb_setting: fail/DIS/E");
				    pin_data->pin_retries = sim_pin_count(MFW_SIM_PIN1);
				    SEND_EVENT(pin_data->pin_win,PIN1_ENDIS_FAIL,0,pin_data);
				  break;
			    default:
				  return 0;
			   }
			break;
			default:
				return 0;
		}
	    return 1;
  }
  /* x0045876, 14-Aug-2006 (WR - missing return statement at end of non-void function) */
   return 0;
}



/*******************************************************************************

 $Function:	set_pin_ch_item_flag
 $Description:	decision about show entry "PIN change"
 $Returns:		Status int; 0 if PIN enabled, 1 if disabled
 $Arguments:	menu tag, menu attribute tag, menu item tag
*******************************************************************************/
U16 set_pin_ch_item_flag (struct MfwMnuTag * m, struct MfwMnuAttrTag * ma, struct MfwMnuItemTag * mi)
{
	T_MFW_SIM_PIN_STATUS status;

    TRACE_FUNCTION("MmiPins:set_pin_item_flag_state:pinChange");

	status.type = MFW_SIM_PIN1;
	sim_pin_status(&status);
	if(status.set EQ MFW_SIM_DISABLE) /*if PIN disabled no change PIN */
		return MNU_ITEM_HIDE;
	else
		return 0;		      /* PIN enabled, change PIN possible */
}


/*******************************************************************************

 $Function:	set_pin_en_item_flag
 $Description:	decision about show entry "PIN enable"
 $Returns:		Status int; 0 if show, 1 if don't show
 $Arguments:	menu tag, menu attribute tag, menu item tag
*******************************************************************************/
U16 set_pin_en_item_flag (struct MfwMnuTag * m, struct MfwMnuAttrTag * ma, struct MfwMnuItemTag * mi)
{
	T_MFW_SIM_PIN_STATUS status;

    TRACE_FUNCTION("MmiPins:set_pin_en_item_flag:pinEnable");

	status.type = MFW_SIM_PIN1;
	sim_pin_status(&status);
	if(status.set EQ MFW_SIM_ENABLE) /*if PIN enabled no show menu entry */
		return MNU_ITEM_HIDE;
	else
		return 0;		      /* PIN disabled show menu entry */
}


/*******************************************************************************

 $Function:	set_pin_dis_item_flag 
 $Description:	decision about show entry "PIN enable"
 $Returns:		Status int; 0 if show, 1 if don't show
 $Arguments:	menu tag, menu attribute tag, menu item tag
*******************************************************************************/
U16 set_pin_dis_item_flag (struct MfwMnuTag * m, struct MfwMnuAttrTag * ma, struct MfwMnuItemTag * mi)
{
	T_MFW_SIM_PIN_STATUS status;

	TRACE_FUNCTION("MmiPins:set_pin_en_item_flag:pinDisable");

	status.type = MFW_SIM_PIN1;
	sim_pin_status(&status);
	if(status.set EQ MFW_SIM_DISABLE) /*if PIN disabled no show menu entry */
		return MNU_ITEM_HIDE;
	else
		return 0;		      /* PIN enabled show menu entry */
}


/*******************************************************************************

 $Function:	set_pin2_ch_item_flag
 $Description:	decision about show entry "PIN2 change"
 $Returns:		Status int; 0 if show, 1 if don't show
 $Arguments:	menu tag, menu attribute tag, menu item tag
*******************************************************************************/
//change back to old version
U16 set_pin2_ch_item_flag (struct MfwMnuTag * m, struct MfwMnuAttrTag * ma, struct MfwMnuItemTag * mi)
{
			T_MFW_SIM_PIN_STATUS status;

    TRACE_FUNCTION("MmiPins:set_pin2_ch_item_flag:pin2Change");

	status.type = MFW_SIM_PIN2;
	sim_pin_status(&status);
	/*if(status.set EQ MFW_SIM_DISABLE)*/ /*if PIN disabled no change PIN */
	if(status.set EQ MFW_SIM_UNKNOWN)
		return MNU_ITEM_HIDE;
	else
		return 0;		      /* PIN enabled, change PIN possible */
}

#ifdef SIM_PERS
/*******************************************************************************
 $Function:		mmi_simlock_change_pin
 $Description:	Performs the change password for a given lock type
 $Returns:		success or failure
 $Arguments:	lock type, oldpassword, new password
*******************************************************************************/

void mmi_simlock_change_pin(T_MFW_HND win,int type,char* oldpsw,char* newpsw)
{
    T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
    T_pin * pin_data = (T_pin *)win_data->user;

    TRACE_EVENT_P2(" old paswwrd%s new password%s ",oldpsw,newpsw);
     if(mfw_simlock_change_lock_code(type,oldpsw,newpsw) !=MFW_SS_OK)
       SEND_EVENT(pin_data->pin_win,SIM_LOCK_NEW_ENDISFAIL,0,pin_data);
    else
        SEND_EVENT(pin_data->pin_win,SIM_LOCK_NEW_ENDSUCC,0,pin_data);
}
#endif

/*******************************************************************************

 $Function:	setting_pin_main 
 $Description:	PIN Settings Dialog Handling function
 $Returns:		none
 $Arguments:	win, event, value, parameters
*******************************************************************************/
void setting_pin_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user;//pin main data
//	T_pin_mess * mess_data = (T_pin_mess *) parameter;//pin message data   /* Warning Correction */
//	T_pin_edt * edt_data = (T_pin_edt *) parameter;//pin editor data   /* Warning Correction */
	T_MFW_WIN * par_window;


	 switch(event)
	 {
		  case PIN1_REQ_OLD:					  // Text "Enter Old Pin "
		  case PIN2_REQ_OLD:					  // Text "Enter Old Pin2 "
		  case PIN1_REQ_ATT:					  // info screen "xx attempts "
		  case PIN2_REQ_ATT:					  // info screen "xx attempts "
		  case PUK1_REQ:					  // Text "Enter Puk "
		  case PIN1_REQ:					  // Text "Enter Pin "
		  case PUK2_REQ:					  // Text "Enter Puk2 "
		  case PIN2_REQ:					  // Text "Enter Pin2 "
		  case PIN1_STATUS:					  // Text "Pin enabled"or disabled
		  case INPUT_NEW_PIN:					  // Text "Enter New PIN "
		  case INPUT_NEW_PIN2:					  // Text "Enter New PIN2 "
		  case INPUT_NEW_PIN_AGAIN:				  // Text "Enter New PIN again "
		  case INPUT_NEW_PIN2_AGAIN:				  // Text "Enter New PIN2 again "
		  case GSM_FAIL:					  // gsm not allowed
		  case NEW_PIN_FAIL:					  // new pin2 failed
		  case NEW_PIN2_FAIL:					  // new pin failed
		  case PUK1_REQ_VER_INFO:				  // Text "Pin blocked "
		  case PUK1_UNBL_FAIL_INFO:				  // unblock error - new puk requ
		  case PUK1_UNBL_FATAL_ERROR:
		  case PIN1_CH_SUCC:
		  case PIN2_CH_SUCC:
		  case PIN1_ENAB_END:
		  case PIN1_DISAB_END:
          case PIN2_SIM_FAILURE:    // Marcus: Issue 1609: 23/01/2003 - failure to verify PIN2
		  
		  case FDN_ACTIVATED:
		  case ADN_ACTIVATED:
		  case FDN_FAIL:
		  case FDN_ACT_END:
		  case FDN_DEACT_END:
#ifdef SIM_PERS              
//The different cases of enabling/disabling/quering and changing password
//scenarios are handled		
case SIM_LOCK_NEW_ENDSUCC_CKEY:
    case INPUT_NEW_SIM_PLOCK_AGAIN:	
          case SIM_LOCK_REQ_NEW:
          case TXT_SIM_LOCK_ALL:
          case SIM_LOCK_ENDSUCC:
          case SIM_LOCK_ALREADY_ENDIS:
          case SIM_LOCK_REQ_FCPWD:
          case SIM_LOCK_FCPWD_FAIL:
          case SIM_LOCK_FCPWDSUCC:
          case SIM_LOCK_REQ_OLD:
          case SIM_LOCK_STATUS:
          case NEW_SIM_PLOCK_FAIL:
          case SIM_LOCK_NEW_ENDSUCC:
          case SIM_LOCK_NEW_ENDISFAIL:
          case SIM_LOCK_SIM_REM:
	   case PERM_BLK:
	   case SMLK_SHOW_FC_FAIL1:
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
	case SIM_LOCK_REQ_MKPWD:	//Master unlock ket request
	case SIM_LOCK_MKPWD_FAIL:	//Master unlocking failed
	case SIM_LOCK_MKPWDSUCC:	//Master unlocking success
#endif
		  sett_pin_mess(win,event);
				  break;
		  case PUK1_UNBL_SUCC: 
					sett_pin_mess(win,event);
				break;
			
	 }

	 switch(event)
	 {
		  case TXT_ENTER_PIN1:
				   pin_data->pin_case = INPUT_PIN1;//enter PIN1 start
				   sett_pin_edit(win,INPUT_PIN1);
				  break;
  #ifdef SIM_PERS
//events to handle input of new password, password and new password again
                 case TXT_ENTER_PLOCK:
                    		pin_data->pin_case = INPUT_SIM_PLOCK;//enter PIN1 start
				sett_pin_edit(win,INPUT_SIM_PLOCK);
                            break;

                  case TXT_ENTER_FCPWD:
                    		pin_data->pin_case = INPUT_SIM_FCPWD;//enter FC pwd start
				sett_pin_edit(win,INPUT_SIM_FCPWD);
                            break;
//x0pleel 20 July, 2006
                  case TXT_ENTER_MKPWD:
                    		pin_data->pin_case = INPUT_SIM_MKPWD;//enter FC pwd start
				sett_pin_edit(win,INPUT_SIM_MKPWD);
                            break;

                   case TXT_ENTER_NEW_SIMLOCK:
                               pin_data->pin_case = INPUT_NEW_SIM_PLOCK;//enter PIN1 start
				   sett_pin_edit(win,INPUT_NEW_SIM_PLOCK);
                                break;  

                      case TXT_ENTER_NEW_SIMLOCK_AGAIN:
                               pin_data->pin_case = INPUT_NEW_SIM_PLOCK_AGAIN;//enter new PIN2 start
				   sett_pin_edit(win,INPUT_NEW_SIM_PLOCK_AGAIN);
				   break;           
                        case NEW_SIM_PLOCK_END:
                              if(!pin_data->puk_request)
                                {
                                    mmi_simlock_change_pin(win,mmi_simlock_locktype,(char*)pin_data->old_pin,(char*)pin_data->new_pin);
                                }
                              break; 

#endif
		  case TXT_ENTER_PIN2:
				   pin_data->pin_case = INPUT_PIN2;//enter PIN2 start
				   sett_pin_edit(win,INPUT_PIN2);
				  break;
#ifdef SIM_PERS
		case ME_PERM_BLK:
				   TRACE_FUNCTION("ME_PERM_BLK");
				   pin_data->pin_case = PERM_BLK1;//enter PUK1 start
				   sett_pin_edit(win,PERM_BLK1);
				  break;
#endif
		  case TXT_ENTER_PUK1:
		  	TRACE_FUNCTION("TXT_ENTER_PUK1");
				   pin_data->pin_case = INPUT_PUK1;//enter PUK1 start
				   sett_pin_edit(win,INPUT_PUK1);
				  break;
		  case TXT_ENTER_PUK2:
				   pin_data->pin_case = INPUT_PUK2;//enter PUK2 start
				   sett_pin_edit(win,INPUT_PUK2);
				  break;
		  case TXT_ENTER_NEW_PIN:
				   pin_data->pin_case = INPUT_NEW_PIN;//enter new PIN start
				   sett_pin_edit(win,INPUT_NEW_PIN);
				   break;
		  case TXT_ENTER_NEW_PIN2:
				   pin_data->pin_case = INPUT_NEW_PIN2;//enter new PIN2 start
				   sett_pin_edit(win,INPUT_NEW_PIN2);
				   break;
		  case TXT_ENTER_NEW_PIN_AGAIN:
				   pin_data->pin_case = INPUT_NEW_PIN_AGAIN;
				   sett_pin_edit(win,INPUT_NEW_PIN_AGAIN);// Start: enter New PIN1 again
				   break;
		  case TXT_ENTER_NEW_PIN_AGAIN2:
				   pin_data->pin_case = INPUT_NEW_PIN2_AGAIN;
				   sett_pin_edit(win,INPUT_NEW_PIN2_AGAIN);// Start: enter New PIN2 again
				   break;
		  case PIN1_END:	
				   pin1_en_dis_verify(win);	
				   break;
				   
#ifdef SIM_PERS                   
//Events that indicate the input of the lock code and new lock code
                case SIM_PLOCK_END:
                               mmi_simlock_en_dis_verify(win);
                               break;

                 case SIM_FCPWD_END:
                 		mmi_simlock_reset_fc_value(win);
                 		break;

			//x0pleela 20 july, 2006 ER: OMAPS00087586, OMAPS00087587
             	   case SIM_MKPWD_END:
             	   		//Master unlocking through SIMP menu
                 		mmi_simlock_master_unlock(win,  MFW_SIM_MKEYM);
                 		break;
#endif                               
		  case PIN2_END:
				   sim_verify_pin(MFW_SIM_PIN2,(char*)pin_data->old_pin);/* verification pin2 */
				   break;
		  case NEW_PIN_END:
				   if(!pin_data->puk_request)
						sim_change_pin(MFW_SIM_PIN1,(U8*)pin_data->old_pin,(U8*)pin_data->new_pin);/* change PIN1 */
				   else
					{
						sim_unblock_pin(MFW_SIM_PUK1, (char*)pin_data->puk, (char*)pin_data->new_pin);/* unblock pin1 */
					}
				   break;
		  case NEW_PIN2_END:
			   if(!pin_data->puk_request)
						sim_change_pin(MFW_SIM_PIN2,(U8*)pin_data->old_pin,(U8*)pin_data->new_pin);/* change PIN2 */
				   else
						sim_unblock_pin(MFW_SIM_PUK2, (char*)pin_data->puk, (char*)pin_data->new_pin);/* unblock pin2 */
				   break;
		  case PIN_OK_INFO: // PIN was need
					if((pin_data->set_state NEQ FDN_ACTIV) AND (pin_data->set_state NEQ FDN_DEACTIV))
					{
						sett_pin_mess(win,PIN_OK_INFO);// for pin2 change and pin2 check from serv/phoneb
					
					}
					else
					{
						set_mode_fdn_adn(win,pin_data);
					}
				   break;
	 }

	 switch(event)
	 {
		  case PIN_OK_END:
				pin_verif_or_check2_end(win);
				break;
		  case PIN1_CH_END:
		  case PIN2_CH_END:
		  case UNBL_OK:
				pin_ch_end_or_abort(win);
			   break;
			
		  case PIN1_STATUS_END: 		  
		  case IDLE_GSM_FAIL:
				   pin_ch_end_or_abort(win);
			   break;
		  case SETT_ABORT:
				TRACE_FUNCTION("clear softkey 10");		  
				// June 16, 2005  REF: CRR 31267  x0021334
				if (pin2Flag NEQ TRUE)  // To ensure that the screen does not blank out
				{
					dspl_ClearAll();
				}
				if(pin_data->set_state EQ PIN1_CHECK)
				{
					par_window = pin_data->parent_win;
					setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
				}
				else if(pin_data->set_state EQ PIN2_CHECK)
				{
					par_window = pin_data->parent_win;
					setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
					// June 16, 2005  REF: CRR 31267  x0021334
					if (pin2Flag EQ TRUE) // To ensure that failed dialog is not given
					{
						pin2Flag = FALSE;
						winDelete(par_window);
					}
					else
						SEND_EVENT(par_window, PIN2_ABORT, 0, NULL);
				}
				else
					setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
				break;
		  case FDN_UNBL_OK:
				TRACE_FUNCTION("clear softkey 11");		  
				setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
				break;
		  case PIN1_ENDIS_FAIL:
				  if(sim_pin_count(MFW_SIM_PIN1) EQ 0)
				  {
					   pin_data->puk_request = TRUE;
					   sett_pin_mess(win,PUK1_REQ_VER_INFO);
				  }
				  else
				  {
						sett_pin_mess(win,PIN1_ENDIS_FAIL);
				  }
				  break;
		  case FDN_WAIT:
			    pin_data->pin_case = FDN_WAIT;
				winShow(pin_data->pin_win);
				break;	// waiting for call back from phonebook handler
#ifdef SIM_PERS				

//event to handle lock/unlock failure			
		case SIM_LOCK_ENDIS_FAIL:
                            sett_pin_mess(win,SIM_LOCK_ENDIS_FAIL);
                            break;

		//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		//New event to display a dialog Busy for wrong entry of unlocking pwd and timer been enabled
		case SIM_LOCK_BUSY:
			       sett_pin_mess(win,SIM_LOCK_BUSY);
                            break;

		//x0pleela 26 July,2006 ER: OMAPS00087586, OMAPS00087587
		//new event to display a dialog Busy for wrong entry of unblocking pwd and timer been enabled
		case SIM_LOCK_BUSY_UNBLOCK:
			       sett_pin_mess(win, SIM_LOCK_BUSY_UNBLOCK);
                            break;
                 
#endif                            
		  default:
			  break;
	 }
}



/*******************************************************************************

 $Function:	pin_ch_end_or_abort 
 $Description:	PIN change finished or abort (settings)
 $Returns:		none
 $Arguments:	win
*******************************************************************************/
static void pin_ch_end_or_abort (T_MFW_HND win)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data
	T_MFW_WIN * par_window;

	TRACE_FUNCTION("MmiPins:pin_ch_end_or_abort");

   if(pin_data->set_state NEQ PIN2_CHECK)
   {
		if((pin_data->set_state EQ FDN_ACTIV) ||(pin_data->set_state EQ FDN_DEACTIV))
		{
			set_mode_fdn_adn(win,pin_data);
		}
		else if(pin_data->set_state EQ PIN1_CHECK)
		{
			par_window = pin_data->parent_win;
			setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
			SEND_EVENT(par_window,PIN1_OK,0,NULL);// pin1 check over PUK1
		}	  
		else
		{
			TRACE_FUNCTION("clear softkey 12");		
			pin_skClear();
			setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog,also idle gsm
		}										/* back to menu tree	  */
   }
   else
   {
		par_window = pin_data->parent_win;
		setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
		SEND_EVENT(par_window,PIN2_OK,0,NULL);// pin2 check over PUK2
   }

}

#ifdef SIM_PERS
//	Nov 03, 2005 DR: OMAPS00052032 - xpradip
/*******************************************************************************
 $Function:		mmi_display_result
 $Description:	Displays appropriate info dialog for the sAT_PlusCLCK operation
 $Returns:		none
 $Arguments:	state for displaying enabled or failed
*******************************************************************************/
void mmi_display_result(U8 state)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)info_disp)->data;
	T_dialog_info * display_info = (T_dialog_info *)win_data->user;
	T_MFW_HND parent = display_info->parent_win;
	T_MFW_WIN * win_data1 = ((T_MFW_HDR *)parent)->data;
	T_pin * pin_data = (T_pin *)win_data1->user;

	if( info_disp)
		dialog_info_destroy(info_disp);
	info_disp = NULL;
	
	if( state)
	{
			SEND_EVENT(parent,SIM_LOCK_ENDSUCC,0,pin_data);
	}
	else
	{
	     if((aciErrDesc & 0x0000FFFF) EQ CME_ERR_SimNotIns)
		     	 SEND_EVENT(parent,SIM_LOCK_SIM_REM,0,pin_data);
	//x0pleela 11 Sep, 2006  DR: OMASP00094215
	//checking for Class type and the ext busy error while unlocking a locked category
	else if( ( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext) AND
			(aciErrDesc & 0x0000FFFF) EQ EXT_ERR_Busy)
 		   	SEND_EVENT(pin_data->pin_win,SIM_LOCK_BUSY,0,pin_data);
	     else
		        SEND_EVENT(parent,SIM_LOCK_ENDIS_FAIL,0,pin_data);
	}
}

static void mmi_simlock_reset_fc_value(T_MFW_HND win)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data
	int status,curr_fail_reset, curr_succ_reset;

	TRACE_FUNCTION("mmi_simlock_reset_fc_value()");
	status = mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
	if( curr_succ_reset )
	{
		status = mfw_simlock_reset_fc_value((U8*)pin_data->old_pin,MFW_SIM_FCM);
		mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);

		if (status == MFW_SS_FAIL)
		{	
			if((aciErrDesc & 0x0000FFFF) EQ CME_ERR_SimNotIns)
		     	 SEND_EVENT(pin_data->pin_win,SIM_LOCK_SIM_REM,0,pin_data);

				//x0pleela 11 Sep, 2006  DR: OMASP00094215
				//checking for Class type and the ext busy error while unlocking a locked category
			else if( ( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext) AND
					(aciErrDesc & 0x0000FFFF) EQ EXT_ERR_Busy)
				{
				  SEND_EVENT(pin_data->pin_win,SIM_LOCK_BUSY_UNBLOCK,0,pin_data);
				}

			else
		     	{
				if( curr_fail_reset )
					{
			     		SEND_EVENT(pin_data->pin_win,SIM_LOCK_FCPWD_FAIL,0,pin_data);
					}
				else
				{
					perm_blocked =1;
					SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
				}
		     	}
		}
         else
             SEND_EVENT(pin_data->pin_win,SIM_LOCK_FCPWDSUCC,0,pin_data);
	}
	else
	{
		perm_blocked =1;
		SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
	}	     
		
   }
/*******************************************************************************
 $Function:		mmi_simlock_en_dis_verify
 $Description:	performs the operation of enabling/disabling and verifying a given
 				lock type after the input of the password
 $Returns:		none
 $Arguments:	none
*******************************************************************************/

static void mmi_simlock_en_dis_verify(T_MFW_HND win)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data
	T_MFW_SS_RETURN ret;
	T_DISPLAY_DATA display_info;

	TRACE_FUNCTION("mmi_simlock_en_dis_verify()");
  if((pin_data->set_state != ENABLE) && (pin_data->set_state != DISABLE))
	{	
              
	       TRACE_FUNCTION("We're verifying SIMLock");
	     
              SEND_EVENT(pin_data->pin_win,SIM_LOCK_REQ_NEW,0,pin_data);
              
       }
  else if(pin_data->set_state EQ ENABLE)
   {	 
		TRACE_FUNCTION("MmiPins:Enable Lock now");
		//TRACE_FUNCTION_P1("Vidya: SimLock_MMI_Enable Password=%s",pin_data->old_pin);	
		ret = mfw_simlock_enable_lock((U8*)pin_data->old_pin, mmi_simlock_locktype);
		if ( ret == MFW_SS_FAIL)
		{	
		     if((aciErrDesc & 0x0000FFFF) EQ CME_ERR_SimNotIns)
		     	 SEND_EVENT(pin_data->pin_win,SIM_LOCK_SIM_REM,0,pin_data);
		     else
		        SEND_EVENT(pin_data->pin_win,SIM_LOCK_ENDIS_FAIL,0,pin_data);
		}
//	Nov 03, 2005 DR: OMAPS00052032 - xpradip
//	handle the execute state for enabling the lock		
		else if( ret == MFW_EXCT)
		{
			dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull,TxtPleaseWait,TxtNull, COLOUR_STATUS);
			dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)NULL, FOREVER, KEY_CLEAR | KEY_LEFT );
			info_disp = info_dialog (pin_data->pin_win, &display_info);
		}
         	else
             		SEND_EVENT(pin_data->pin_win,SIM_LOCK_ENDSUCC,0,pin_data);
   }
   else  if(pin_data->set_state EQ DISABLE)
   { 	
   		ret = mfw_simlock_disable_lock((U8*)pin_data->old_pin,mmi_simlock_locktype); 
		if (ret == MFW_SS_FAIL)
		{	
		      if((aciErrDesc & 0x0000FFFF) EQ CME_ERR_SimNotIns)
		     	 SEND_EVENT(pin_data->pin_win,SIM_LOCK_SIM_REM,0,pin_data);

				//x0pleela 11 Sep, 2006  DR: OMASP00094215
				//checking for Class type and the ext busy error while unlocking a locked category
			else if( ( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext) AND
					(aciErrDesc & 0x0000FFFF) EQ EXT_ERR_Busy)
			  SEND_EVENT(pin_data->pin_win,SIM_LOCK_BUSY,0,pin_data);
		     else
  			{
  			pin_data->pin_retries = sim_pin_count(MFW_SIM_PIN1);
			SEND_EVENT(pin_data->pin_win,SIM_LOCK_ENDIS_FAIL,0,pin_data);
		     	}
		}
        	else
	       		SEND_EVENT(pin_data->pin_win,SIM_LOCK_ENDSUCC,0,pin_data);
   }

}


/*******************************************************************************
 $Function:		simLock_enable
 $Description:	Initiates the password input screen for enabling a lock	none
 $Arguments:	none
*******************************************************************************/
void SIMLock_enable ()
{
    T_MFW_HND idle_win = mfwParent( mfw_header() );
    T_MFW_HND win = setting_pin_create(idle_win);
    UBYTE slock_status;
    T_MFW_WIN * win_data = NULL;
    T_pin * pin_data = NULL;

    if(win != NULL) /* x0039928 -Lint warning removal */
    {
    	win_data = ((T_MFW_HDR *)win)->data;

    pin_data = (T_pin *)win_data->user;
	
    /*a0393213 warnings removal-status variable set but not used*/	
    /*T_MFW_SIM_PIN_STATUS status; 

    status.type = MFW_SIM_PLOCK;*/
    slock_status= mfw_simlock_get_lock_status(mmi_simlock_locktype);
    pin_data->set_state = ENABLE;

    if(slock_status EQ MFW_SIM_DISABLE) /*if PIN disabled*/
    {	
        SEND_EVENT(pin_data->pin_win,TXT_SIM_LOCK_ALL,0,pin_data);	
     }
    else if (slock_status EQ MFW_SIM_BLOCKED)
    {
    	pin_data->pin_case = SIM_LOCK_ALL;
    	SEND_EVENT(pin_data->pin_win, SIM_LOCK_ENDIS_FAIL,0,pin_data);
     }
    else 
        SEND_EVENT(pin_data->pin_win,SIM_LOCK_ALREADY_ENDIS,0,pin_data);
    	}
}

/*******************************************************************************

 $Function:		SIMLock_disable
 $Description:	Initiates the password input screen for the disabling of a lock
 $Returns:		
 $Arguments:	
*******************************************************************************/
void SIMLock_disable ()
{
		T_MFW_HND idle_win = mfwParent( mfw_header() );
		T_MFW_HND win = setting_pin_create(idle_win);
        	UBYTE slock_status;
		T_MFW_WIN * win_data = NULL;
  //     	T_DISPLAY_DATA display_info;
		T_pin * pin_data = NULL;
		/*T_MFW_SIM_PIN_STATUS status;*//*a0393213 warnings removal-status variable set but not used*/

            TRACE_FUNCTION("SIMLock_disable()");    

		if(win != NULL) /* x0039928 - Lint warning removal */
  		{	win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;
		
		/*status.type = MFW_SIM_PLOCK;*/ /*a0393213 warnings removal-status variable set but not used*/
		slock_status= mfw_simlock_get_lock_status(mmi_simlock_locktype);
		pin_data->set_state = DISABLE;
		if(slock_status EQ MFW_SIM_ENABLE) /*if PIN disabled*/
		{	
			SEND_EVENT(pin_data->pin_win,TXT_SIM_LOCK_ALL,0,pin_data);	
		}
		else if (slock_status EQ MFW_SIM_BLOCKED)
	    {
	    	pin_data->pin_case = SIM_LOCK_ALL;
	    	SEND_EVENT(pin_data->pin_win, SIM_LOCK_ENDIS_FAIL,0,pin_data);
		}
		else //PIN already enabled
		/*{
			dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, TxtLockDisabled, TxtNull,  COLOUR_STATUS_PINS);
          	//display_info.TextId = TxtLockEnabled;
          	dlg_initDisplayData_events( &display_info, NULL, THREE_SECS, 0 );
          	info_dialog(0,&display_info);
		}*/
			SEND_EVENT(pin_data->pin_win,SIM_LOCK_ALREADY_ENDIS,0,pin_data);
		}
		return ;
}


/*******************************************************************************
 $Function:		SIMLock_change
 $Description:	Initiates the password input screen for change password
 $Arguments:	none
*******************************************************************************/

 void SIMLock_change ()
{
    T_MFW_HND idle_win = mfwParent( mfw_header());
    T_MFW_HND win = setting_pin_create(idle_win);
    T_MFW_WIN * win_data = NULL;
    T_pin * pin_data = NULL;
    int status;
   
	if(win != NULL)	/* x0039928 - Lint warning removal */
	{
	win_data = ((T_MFW_HDR *)win)->data;
	pin_data = (T_pin *)win_data->user;
	pin_data->set_state = CHANGE_PIN;
	status = mfw_simlock_get_lock_status(mmi_simlock_locktype);
	
	TRACE_FUNCTION("MmiPins:SIMLock_change");
	
	if(status == MFW_SIM_BLOCKED)
	{
		pin_data->pin_case = SIM_LOCK_ALL;
		SEND_EVENT(pin_data->pin_win,SIM_LOCK_ENDIS_FAIL,0,pin_data);
	}
	else if( status == MFW_SIM_ENABLE){
		SEND_EVENT(pin_data->pin_win,SIM_LOCK_STATUS,0,pin_data);
		}
	else
    {
      /*a0393213 warnings removal - enumerated typed mixed with other type - the statement is not necessary*/
    	/*pin_data->pin_case = DISABLE;*/
    	SEND_EVENT(pin_data->pin_win,SIM_LOCK_REQ_OLD,0,pin_data);
    }
	}
}

/*******************************************************************************

 $Function:		SIMLock_status  
 $Description:	Initiates the query for the lock status.
 $Returns:		
 $Arguments:none
*******************************************************************************/
void SIMLock_status ()
{

		T_MFW_HND idle_win = mfwParent( mfw_header() );
		T_MFW_HND win = setting_pin_create(idle_win);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;

	if(win != NULL) /* x0039928 - Lint warning removal */
	{
		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;


	    TRACE_FUNCTION("SIMLock_status");

	    SEND_EVENT(pin_data->pin_win,SIM_LOCK_STATUS,0,pin_data);
	}
}


/*******************************************************************************

 $Function:    	simlock_doAction

 $Description:	
            
 $Returns:		

 $Arguments:	
 
*******************************************************************************/

void simlock_doAction()
{
TRACE_FUNCTION("simlock_doAction()");
	switch(mmi_simlock_lockaction)
		{
		case MFW_SIM_ENABLE:
			SIMLock_enable();
			break;

		case MFW_SIM_DISABLE:
			SIMLock_disable();
			break;

		case MFW_SIM_CHANGE:
			SIMLock_change();
			break;
		case MFW_SIM_VERIFY:
			SIMLock_status();
			break;
			
		default:
			break;
		}
}

int SIMLock_resetFC (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
		T_MFW_HND idle_win = mfwParent( mfw_header() );
		T_MFW_HND win = setting_pin_create(idle_win);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;
		
		if(win != NULL) /* x0039928 -Lint warning removal */
		{
		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;

            	TRACE_FUNCTION("SIMLock_resetFC()");    
            	
	    	SEND_EVENT(pin_data->pin_win, SIM_LOCK_REQ_FCPWD,0,pin_data);
		}
		return 1;
}

/*******************************************************************************

 $Function:    	mmi_simlock_category_menus()

 $Description:	starts the simlock category list menu
 
 $Returns:		None

 $Arguments:	parent window
 
*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
T_MFW_HND mmi_simlock_category_menus(T_MFW_HND parent)
{	
	T_MFW_HND simp_cat_list_win;
	TRACE_FUNCTION("mmi_simlock_category_menus");
	
	simp_cat_list_win = bookMenuStart(parent, SIMPCategoryListAttributes(), NULL);
	return  simp_cat_list_win;

}

/*******************************************************************************
 $Function:		SIMLock_unblock_ME
 $Description:	       This function sends an event to display an editor for the user to enter
 				unblocking code
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
int SIMLock_unblock_ME(struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
  T_MFW_HND 		pin_win = pin_windows;
  T_MFW_WIN * win_data = ((T_MFW_HDR *)pin_win)->data;
  T_pin * pin_data = (T_pin *)win_data->user; // pin main data

  TRACE_FUNCTION("SIMLock_unblock_ME()");
  
  pin_data->puk_request = TRUE;
  C_KEY_REQ=1;
  FCUnlock_flag=1;
  SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
  return 1;
}

/*******************************************************************************
 $Function:		SIMLock_MasterKeyUnlock_bootup
 $Description:	       This functioh gets called to unlock category /unblock ME during bootup sequence
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
int SIMLock_MasterKeyUnlock_bootup (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
  T_MFW_HND 		pin_win = pin_windows;
  T_MFW_WIN * win_data = ((T_MFW_HDR *)pin_win)->data;
  T_pin * pin_data = (T_pin *)win_data->user; // pin main data
  
  TRACE_FUNCTION("SIMLock_MasterKeyUnlock_bootup()");    
  
  SEND_EVENT(pin_data->pin_win, INPUT_MASTER_KEY_REQ,0,pin_data);
  
  return 1;
}

/*******************************************************************************
 $Function:		SIMLock_MasterKeyUnlock
 $Description:	       This functioh gets called to unlock category /unblock ME through SIMP menu
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
int SIMLock_MasterKeyUnlock (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
  T_MFW_HND idle_win = mfwParent( mfw_header() );
  T_MFW_HND win = setting_pin_create(idle_win);
  T_MFW_WIN * win_data = NULL;
  T_pin * pin_data = NULL;

  if(win != NULL) /* x0039928 - Lint warning removal */
  {
  win_data = ((T_MFW_HDR *)win)->data;
  pin_data = (T_pin *)win_data->user;
  
  TRACE_FUNCTION("SIMLock_MasterKeyUnlock()");    
  SEND_EVENT(pin_data->pin_win, SIM_LOCK_REQ_MKPWD,0,pin_data);
  }
  return 1;
}

/*******************************************************************************

 $Function:    	simlock_check_masterkey

 $Description:   If there is no support for Master Unlocking the item "Master unlock" will not 
 				appear on the menulist

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
USHORT	simlock_check_masterkey(struct MfwMnuTag *m, 
									   struct MfwMnuAttrTag *ma, 
									   struct MfwMnuItemTag *mi)

{
	UBYTE status;
	TRACE_FUNCTION("simlock_check_masterkey");

	status = mfw_simlock_check_masterkey(MFW_SIM_MKEYM);
	if( status EQ MFW_MASTER_UNLOCK_ACTIVE)
	  return 0;
	else
	  return 1;
}

/*******************************************************************************

 $Function:    	simlock_get_masterkey_status

 $Description:   Get the master key status

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
UBYTE simlock_get_masterkey_status(void)

{
	UBYTE status;
	TRACE_FUNCTION("simlock_get_masterkey_status");

	status = mfw_simlock_check_masterkey(MFW_SIM_MKEYM);
	return status;	
}

/*******************************************************************************

 $Function:    	simlock_check_NWCatLock

 $Description:   Get the lock status of Network category and accordingly display the menu item

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
USHORT	simlock_check_NWCatLock(struct MfwMnuTag *m, 
									   struct MfwMnuAttrTag *ma, 
									   struct MfwMnuItemTag *mi)

{
	int status;
	
	TRACE_FUNCTION("simlock_check_NWCatLock");

	status = mfw_simlock_get_lock_status(mmi_simlock_locktype);
	if( (mmi_simlock_locktype EQ MFW_SIM_NLOCK ) && ( status NEQ MFW_SIM_BLOCKED) )
		return 0;
	else
		return 1;	
	
}

/*******************************************************************************

 $Function:    	simlock_check_NSCatLock

 $Description:   Get the lock status of Network subset category and accordingly display the menu item

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
USHORT	simlock_check_NSCatLock(struct MfwMnuTag *m, 
									   struct MfwMnuAttrTag *ma, 
									   struct MfwMnuItemTag *mi)

{
	int status;
	
	TRACE_FUNCTION("simlock_check_NSCatLock");


	status = mfw_simlock_get_lock_status(mmi_simlock_locktype);
	if( (mmi_simlock_locktype EQ MFW_SIM_NSLOCK )&& ( status NEQ MFW_SIM_BLOCKED) )
		return 0;
	else
		return 1;	
}

/*******************************************************************************

 $Function:    	simlock_check_SPCatLock

 $Description:   Get the lock status of Service Provider category and accordingly display the menu item

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
USHORT	simlock_check_SPCatLock(struct MfwMnuTag *m, 
									   struct MfwMnuAttrTag *ma, 
									   struct MfwMnuItemTag *mi)

{
	int status;
	
	TRACE_FUNCTION("simlock_check_SPCatLock");

	status = mfw_simlock_get_lock_status(mmi_simlock_locktype);
	if( (mmi_simlock_locktype EQ MFW_SIM_SPLOCK )&& ( status NEQ MFW_SIM_BLOCKED) )
		return 0;
	else
		return 1;		
}

/*******************************************************************************

 $Function:    	simlock_check_CPCatLock

 $Description:   Get the lock status of Corporate category and accordingly display the menu item

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
USHORT	simlock_check_CPCatLock(struct MfwMnuTag *m, 
									   struct MfwMnuAttrTag *ma, 
									   struct MfwMnuItemTag *mi)

{
	int status;
	
	TRACE_FUNCTION("simlock_check_CPCatLock");

	status = mfw_simlock_get_lock_status(mmi_simlock_locktype);
	if( (mmi_simlock_locktype EQ MFW_SIM_CLOCK )&& ( status NEQ MFW_SIM_BLOCKED) )
		return 0;
	else
		return 1;		
}

/*******************************************************************************

 $Function:    	simlock_check_SIMCatLock

 $Description:   Get the lock status of SIM category and accordingly display the menu item

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
USHORT	simlock_check_SIMCatLock(struct MfwMnuTag *m, 
									   struct MfwMnuAttrTag *ma, 
									   struct MfwMnuItemTag *mi)

{
	int status;
	
	TRACE_FUNCTION("simlock_check_SIMCatLock");

	status = mfw_simlock_get_lock_status(mmi_simlock_locktype);
	if( (mmi_simlock_locktype EQ MFW_SIM_PLOCK )&& ( status NEQ MFW_SIM_BLOCKED) )
		return 0;
	else
		return 1;		
}

/*******************************************************************************

 $Function:    	simlock_check_CatBlock

 $Description:   Get the ME status and accordingly display the menu item

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
USHORT	simlock_check_CatBlock(struct MfwMnuTag *m, 
									   struct MfwMnuAttrTag *ma, 
									   struct MfwMnuItemTag *mi)
{
	T_SUP_INFO_TYPE FLAG;
	int curr_fc;

	TRACE_FUNCTION("simlock_check_CatBlock");

 	FLAG=FCATTEMPTSLEFT;          /* set flag to current */
     	curr_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/	
	if((curr_fc == 0)) //ME blocked
		return 0;
	else
		return 1;
}
/*******************************************************************************

 $Function:    	mmi_simlock_master_unlock

 $Description:   This function unlocks category/unblocks ME and sends event accordingly through SIMP menu

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
static void mmi_simlock_master_unlock(T_MFW_HND win, UBYTE MK_Unblock_flag)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data
	int status;

	TRACE_FUNCTION("mmi_simlock_master_unlock()");

	status = mfw_simlock_master_unlock((U8*)pin_data->old_pin, MK_Unblock_flag);
	if (status == MFW_SS_FAIL)
		{
		SEND_EVENT(pin_data->pin_win,SIM_LOCK_MKPWD_FAIL,0,pin_data);			
		}
       else
       	{
      	       SEND_EVENT(pin_data->pin_win,SIM_LOCK_MKPWDSUCC,0,pin_data);
       	}
}

/*******************************************************************************

 $Function:    	simlock_check_PBCatLock

 $Description:   Get the lock status of Blocked Network category and accordingly display the menu item

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 25 Sep, 2006 ER: OMAPS00095524
USHORT	simlock_check_PBCatLock(struct MfwMnuTag *m, 
									   struct MfwMnuAttrTag *ma, 
									   struct MfwMnuItemTag *mi)

{
	int status;
	
	TRACE_FUNCTION("simlock_check_PBCatLock");

	status = mfw_simlock_get_lock_status(mmi_simlock_locktype);
	if( (mmi_simlock_locktype EQ MFW_SIM_PBLOCK ) && ( status NEQ MFW_SIM_BLOCKED) )
		return 0;
	else
		return 1;	
	
}

/*******************************************************************************

 $Function:    	simp_unlock_Category

 $Description:   This function sends corresponding event to unlock a locked category through dynamic menu

 $Returns:

 $Arguments:

*******************************************************************************/
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
int simp_unlock_Category(struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
	T_MFW_HND 		pin_win = pin_windows;
	T_MFW_WIN * win_data = ((T_MFW_HDR *)pin_win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data
	
	TRACE_FUNCTION("simp_unlock_Category()");
	switch((int)i->str)
	{
	case TxtNetwork:
		SEND_EVENT(pin_win,INPUT_NLOCK_PIN_REQ, 0, pin_data);
		break;
	case TxtNetworkSubset:
		SEND_EVENT(pin_win,INPUT_NSLOCK_PIN_REQ, 0, pin_data);
		break;
	case TxtServiceProvider:
		SEND_EVENT(pin_win,INPUT_SPLOCK_PIN_REQ, 0, pin_data);
		break;
	case TxtCorporate:
		SEND_EVENT(pin_win,INPUT_CLOCK_PIN_REQ, 0, pin_data);
		break;
	case TxtSIM:
		SEND_EVENT(pin_win,INPUT_SIM_PIN_REQ, 0, pin_data);
		break;		

	//x0pleela 25 Sep, 2006 ER: OMAPS00095524
	//Handling "Blocked Network" category
	case TxtBlkNetwork:
		SEND_EVENT(pin_win,INPUT_PBLOCK_PIN_REQ, 0, pin_data);
		break;	
	}	
	return MFW_EVENT_CONSUMED;
}

/*******************************************************************************
 $Function:		get_fc_max_value
 $Description:	       gets the maximum value of FC
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
int get_fc_max_value (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int max_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
     FLAG=FCMAX;          /* set flag to current */

     TRACE_FUNCTION("get_fc_max_value");
     max_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(max_fc != MFW_FAILURE)
     	{
     sprintf(buf, "MAX %d tries", max_fc);
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}

/*******************************************************************************
 $Function:		get_fc_attempts_left
 $Description:	       gets the current value of FC
 $Returns:		none 
 $Arguments:	       none
*******************************************************************************/
int get_fc_attempts_left (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int curr_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
//	Sept 24, 2005 REF:  LOCOSTO-ENH-34438, xpradipg
//	new ENUM used to adopt to the aci label
     FLAG = FCATTEMPTSLEFT;          /* set flag to current */
     
     curr_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(curr_fc != MFW_FAILURE)
     	{
     sprintf(buf, "%d tries left", curr_fc);
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}



/*******************************************************************************
 $Function:		get_fail_reset_fc_max_value
 $Description:	       gets the maximum value of FC
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
int get_fail_reset_fc_max_value (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int max_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
     FLAG=FCRESETFAILMAX;          /* set flag to current */
     
     max_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(max_fc != MFW_FAILURE)
     	{
     sprintf(buf, "MAX %d tries", max_fc);
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}

/*******************************************************************************
 $Function:		get_succ_reset_fc_max_value
 $Description:	       gets the maximum value of FC
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
int get_succ_reset_fc_max_value (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int max_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
     FLAG=FCRESETSUCCESSMAX;          /* set flag to current */
     
     max_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(max_fc != MFW_FAILURE)
     	{
     sprintf(buf, "MAX %d tries", max_fc);
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}
/*******************************************************************************
 $Function:		get_fail_reset_fc_attempts_left
 $Description:	       gets the maximum value of FC
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
int get_fail_reset_fc_attempts_left (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int max_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
//	Sept 24, 2005 REF:  LOCOSTO-ENH-34438, xpradipg
//	new ENUM used to adopt to the aci label	 
     FLAG = FCRESETFAILATTEMPTSLEFT;          /* set flag to current */
     
     max_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(max_fc != MFW_FAILURE)
     	{
     sprintf(buf, "%d tries left", max_fc);
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}
/*******************************************************************************
 $Function:		get_succ_reset_fc_attempts_left
 $Description:	       gets the maximum value of FC
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
int get_succ_reset_fc_attempts_left (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int max_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
//	Sept 24, 2005 REF:  LOCOSTO-ENH-34438, xpradipg
//	new ENUM used to adopt to the aci label	 
     FLAG=FCRESETSUCCESSATTEMPTSLEFT;          /* set flag to current */
     
     max_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(max_fc != MFW_FAILURE)
     	{
     sprintf(buf, "%d tries left", max_fc);
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}
/*******************************************************************************
 $Function:		get_timer_flag_value
 $Description:	       gets the value of timer for successive unlock attempts
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
int get_timer_flag_value (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int max_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
     FLAG=TIMERFLAG;          /* set flag to current */
     
     max_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(max_fc != MFW_FAILURE)
     	{
     	if( max_fc )
	     sprintf(buf, "Flag Enabled");
     	else
     		sprintf(buf,"Flag Disabled");
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}

/*******************************************************************************
 $Function:		get_airtel_ind_flag_value
 $Description:	       gets the value of airtel indication flag
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
int get_airtel_ind_flag_value (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int max_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
     FLAG=AIRTELINDFLAG;          /* set flag to current */
     
     max_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(max_fc != MFW_FAILURE)
     	{
     	if( max_fc )
	     sprintf(buf, "Flag Enabled");
     	else
     		sprintf(buf,"Flag Disabled");
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}

/*******************************************************************************
 $Function:		get_etsi_flag_value
 $Description:	       gets the value of ETSI flag
 $Returns:		none
 $Arguments:	       none
*******************************************************************************/
int get_etsi_flag_value (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
   
    T_SUP_INFO_TYPE FLAG;
     int max_fc;
     T_MFW_HND       win  = mfwParent(mfw_header());
     T_DISPLAY_DATA display_info;
     char buf[30];
     FLAG=ETSIFLAG;          /* set flag to current */
     
     max_fc=mfw_simlock_get_sup_info(FLAG); /* get the value of the corresponding flag*/
     
     if(max_fc != MFW_FAILURE)
     	{
     	if( max_fc )
	     sprintf(buf, "Flag Enabled");
     	else
     		sprintf(buf,"Flag Disabled");
     dlg_initDisplayData_TextStr( &display_info, TxtNull,  TxtNull, (char *)buf, (char *)NULL, COLOUR_STATUS);
     	}
     else
     dlg_initDisplayData_TextId( &display_info, TxtNull,  TxtNull, TxtFailed, TxtNull, COLOUR_STATUS);
     
     dlg_initDisplayData_events( &display_info, NULL, TWO_SECS, KEY_OK );
    // display_info.TextString2   = NULL; 
     display_info.Identifier   = NULL;
      info_dialog(win,&display_info); //information screen
      
      return 1;
   
}

/*******************************************************************************
 $Function:		setLockTypeNw
 $Description:	sets the global flag to the network lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int setLockTypeNw (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
       TRACE_FUNCTION("setLockTypeNw"); 
	mmi_simlock_locktype=MFW_SIM_NLOCK;
	simlock_doAction();
	return 1;
}
/*******************************************************************************
 $Function:		setLockTypeSp
 $Description:	sets the global flag to the Service provider lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int setLockTypeSp (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
       TRACE_FUNCTION("setLockTypeNw");
	mmi_simlock_locktype=MFW_SIM_SPLOCK;
	simlock_doAction();
	return 1;
}
/*******************************************************************************
 $Function:		setLockTypeNs
 $Description:	sets the global flag to the network subset lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int setLockTypeNs (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
       TRACE_FUNCTION("setLockTypeNs");
	mmi_simlock_locktype=MFW_SIM_NSLOCK;
	simlock_doAction();
	return 1;
}
/*******************************************************************************
 $Function:		setLockTypeCp
 $Description:	sets the global flag to the Corprate lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int setLockTypeCp (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
       TRACE_FUNCTION("setLockTypeCp");
	mmi_simlock_locktype=MFW_SIM_CLOCK;
	simlock_doAction();
	return 1;
}
/*******************************************************************************
 $Function:		setLockTypePs
 $Description:	sets the global flag to the Personalisation lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int setLockTypePs(struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
       TRACE_FUNCTION("setLockTypePs");
	mmi_simlock_locktype=MFW_SIM_PLOCK;
	simlock_doAction();
	return 1;
}


/*******************************************************************************
 $Function:		setLockTypePb
 $Description:		sets the global flag to the Personalisation lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
//x0pleela 25 Sep, 2006 ER: OMAPS00095524
int setLockTypePb(struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
       TRACE_FUNCTION("setLockTypePb");
	mmi_simlock_locktype=MFW_SIM_PBLOCK;
	simlock_doAction();
	return 1;
}
/*******************************************************************************

 $Function:    	setLockActionLock

 $Description:	
            
 $Returns:		

 $Arguments:	
 
*******************************************************************************/


void setLockActionLock(void)
{
    TRACE_FUNCTION("setLockActionLock");
    mmi_simlock_lockaction= MFW_SIM_ENABLE;
}


/*******************************************************************************

 $Function:    	setLockActionUnlock

 $Description:	sets the global flag to the action unlock
            
 $Returns:		none

 $Arguments:	none
 
*******************************************************************************/


void setLockActionUnlock(void)
{
    TRACE_FUNCTION("setLockActionUnlock");
    mmi_simlock_lockaction= MFW_SIM_DISABLE;
}
/*******************************************************************************

 $Function:    	setLockActionChPwd

 $Description:	
            
 $Returns:		

 $Arguments:	
 
*******************************************************************************/


void setLockActionChPwd(void)
{
    TRACE_FUNCTION("setLockActionChPwd");
    mmi_simlock_lockaction= MFW_SIM_CHANGE;
}

/*******************************************************************************

 $Function:    	setLockActionChkStat

 $Description:	
            
 $Returns:		

 $Arguments:	
 
*******************************************************************************/


void setLockActionChkStat(void)
{
    TRACE_FUNCTION("setLockActionChkStat");
    mmi_simlock_lockaction= MFW_SIM_VERIFY;
}

#endif



/*******************************************************************************

 $Function:	pin_verif_or_check2_end
 $Description:	PIN change finished or abort (settings)
 $Returns:		none
 $Arguments:	win
****************************************************************************/
static void pin_verif_or_check2_end(T_MFW_HND win)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data
	T_MFW_WIN * par_window;

	TRACE_FUNCTION("MmiPins:pin_verif_or_check2_end");

  if(pin_data->set_state NEQ PIN2_CHECK)
   {
		if(pin_data->set_state NEQ CHANGE_PIN2)
		{
			TRACE_FUNCTION("MmiPins:changing PIN 2");
			SEND_EVENT(pin_data->pin_win,INPUT_NEW_PIN,0,pin_data);//pin change
		}
		else if(pin_data->set_state EQ PIN1_CHECK)
		{
			par_window = pin_data->parent_win;
			setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
			SEND_EVENT(par_window,PIN1_OK,0,NULL);// pin1 check (not over PUK1)
		}
		else
		{
			TRACE_FUNCTION("MmiPins:changing PIN 2");
			SEND_EVENT(pin_data->pin_win,INPUT_NEW_PIN2,0,pin_data);// pin2 change
		}

   }
   else
   {	TRACE_FUNCTION("MmiPins:checking PIN 2");
		par_window = pin_data->parent_win;
		setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
		SEND_EVENT(par_window,PIN2_OK,0,NULL);// pin2 check (not over PUK2)
   }

}




/*******************************************************************************

 $Function:	pin1_en_dis_verify 
 $Description:	PIN enab/disab/verify start
 $Returns:		none
 $Arguments:	win
****************************************************************************/
static void pin1_en_dis_verify(T_MFW_HND win)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	TRACE_FUNCTION("MmiPins:pin1_en_dis_verify");

   if((pin_data->set_state NEQ ENABLE) AND (pin_data->set_state NEQ DISABLE))
	{	TRACE_FUNCTION("We're verifying pin 1");
		sim_verify_pin(MFW_SIM_PIN1,(char*)pin_data->old_pin);/* verification pin1 */
	}
   else if(pin_data->set_state EQ ENABLE)
   {	/* start enabling PIN1 */ 
		TRACE_FUNCTION("MmiPins:Pin1 now enabled");   
		if (sim_enable_pin((U8*)pin_data->old_pin) == MFW_SS_FAIL)
		{	/*SPR 2145, if attempt fails then behave as though a "Pin incorrect"
			event has been sent to MMI*/
 			 pin_data->pin_retries = sim_pin_count(MFW_SIM_PIN1);
		     SEND_EVENT(pin_data->pin_win,PIN1_ENDIS_FAIL,0,pin_data);
		}
			
   }
   else 
   { 	/* start disabling PIN1 */
		TRACE_FUNCTION("MmiPins:Pin1 now disabled");   
		if (sim_disable_pin((U8*)pin_data->old_pin) == MFW_SS_FAIL)
		{	/*SPR 2145, if attempt fails then behave as though a "Pin incorrect"
			event has been sent to MMI*/
  			pin_data->pin_retries = sim_pin_count(MFW_SIM_PIN1);
			SEND_EVENT(pin_data->pin_win,PIN1_ENDIS_FAIL,0,pin_data);
		}
   }

}

/*******************************************************************************

 $Function:	pin_change 
 $Description:	PIN change : call from menu Settings
 $Returns:		Status int
 $Arguments:	menu, item
*******************************************************************************/

int pin_change (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
		T_MFW_HND idle_win = idle_get_window();
		T_MFW_HND win = setting_pin_create(idle_win);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;
		T_MFW_SIM_PIN_STATUS status;
			
		if(win != NULL) /* x0039928 - Lint warning removal */
		{	win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;

		pin_data->set_state = CHANGE_PIN;

	TRACE_FUNCTION("MmiPins:pin_change");

	status.type = MFW_SIM_PIN1;
		sim_pin_status(&status);
		if(status.set EQ MFW_SIM_ENABLE) /*if PIN enabled no show menu entry */
		{	if(sim_pin_count(MFW_SIM_PIN1) > 0)
				SEND_EVENT(pin_data->pin_win,PIN1_REQ_OLD,0,pin_data);
			else
			{   /* not included the state of the puk counter ! */
				pin_data->puk_request = TRUE;
				SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
			}
		}
		else
		{
			setting_pin_destroy(win);
			pin1_not_enabled_screen();
		}
		}
		return 1;
}


/*******************************************************************************

 $Function:	pin2_change 
 $Description:	PIN2 change : call from menu Settings
 $Returns:		Status int
 $Arguments:	menu, item
*******************************************************************************/
int pin2_change (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
		T_MFW_HND idle_win = idle_get_window();
		T_MFW_HND win = setting_pin_create(idle_win);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;
		
		if(win != NULL) /* x0039928 - Lint warning removal */
		{	win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;

		pin_data->set_state = CHANGE_PIN2;

	TRACE_FUNCTION("MmiPins:pin2_change");
	      // June 16, 2005  REF: CRR 31267  x0021334
	      // Check if PIN2 and PUK2 are initialised
		if((sim_pin_count(MFW_SIM_PIN2) > 0) AND (sim_pin_count(MFW_SIM_PUK2) NEQ 0))
			SEND_EVENT(pin_data->pin_win,PIN2_REQ_OLD,0,pin_data);
		// If PIN2 is not initialised, ask for PUK 2
		else if ((sim_pin_count(MFW_SIM_PIN2) EQ 0) AND (sim_pin_count(MFW_SIM_PUK2) > 0))
		{
			pin_data->puk_request = TRUE;
			SEND_EVENT(pin_data->pin_win,PUK2_REQ,0,pin_data);
		}
		// Else display that PIN2 is not available
		else
		{
			SEND_EVENT(pin_data->pin_win,PIN2_SIM_FAILURE,0,pin_data);
		}
		}
		return 1;
}


/*******************************************************************************

 $Function:	pin_enable
 $Description:	PIN1 enable : call from menu Settings
 $Returns:		Status int
 $Arguments:	menu, item
*******************************************************************************/
int pin_enable (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
		T_MFW_HND idle_win = mfwParent( mfw_header() );
		T_MFW_HND win = setting_pin_create(idle_win);
		T_MFW_SIM_PIN_STATUS status;
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;
		
		if(win != NULL)  /* x0039928 - Lint warning removal */
		{
		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;
    
		status.type = MFW_SIM_PIN1;//get pin1 status
		sim_pin_status(&status);
		if(status.set EQ MFW_SIM_DISABLE) /*if PIN disabled*/
		{	pin_data->set_state = ENABLE;
			if(sim_pin_count(MFW_SIM_PIN1) > 0) //if PIN1 not blocked
			{	//ask for PIN1
			    SEND_EVENT(pin_data->pin_win,PIN1_REQ,0,pin_data);	
			}
			else
			{	//ask for PUK1
				pin_data->puk_request = TRUE;
			 SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
			}
		}
		else //PIN already enabled
			SEND_EVENT(pin_data->pin_win,PIN1_ENAB_END,0,pin_data);
		}
		return 1;
}



/*******************************************************************************

 $Function:	pin_disable
 $Description:	PIN1 disable : call from menu Settings
 $Returns:		Status int
 $Arguments:	menu, item
*******************************************************************************/
int pin_disable (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
		T_MFW_HND idle_win =mfwParent( mfw_header() );
		T_MFW_HND win = setting_pin_create(idle_win);
		T_MFW_SIM_PIN_STATUS status;
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;

		if(win != NULL) /* x0039928 - Lint warning removal */
		{	win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;


    TRACE_FUNCTION("MmiPins:pin_disable");
		status.type = MFW_SIM_PIN1; //get pin1 status
		sim_pin_status(&status);
		/*MC CONQ 5578, 27/05/02, if pin disabling NOT available*/
		if(status.stat EQ MFW_SIM_NO_DISABLE)
		{	/*tell user and destroy PIN window*/
			ShowMessage(win, TxtNotAllowed, TxtNull);
			setting_pin_destroy(win);
		}
		else
		{
			/*if PIN enabled */
			if(status.set EQ MFW_SIM_ENABLE )
			{
				pin_data->set_state = DISABLE;
				if(sim_pin_count(MFW_SIM_PIN1) > 0) //if PIN not blocked
				{//ask for PIN
				 SEND_EVENT(pin_data->pin_win,PIN1_REQ,0,pin_data);
				}
				else
				{	//ask for PUK1
				    pin_data->puk_request = TRUE;
					SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
				}
			}
			else //if PIN already disabled no need to ask for PIN
				SEND_EVENT(pin_data->pin_win,PIN1_DISAB_END,0,pin_data);
		}
	}
		return 1;
}


/*******************************************************************************

 $Function:	pin_status  
 $Description:	how if pin request is on or off
 $Returns:		Status int
 $Arguments:	menu, item
*******************************************************************************/
int pin_status (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{

		T_MFW_HND idle_win = idle_get_window();
		T_MFW_HND win = setting_pin_create(idle_win);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;
		
		if(win != NULL) /* x0039928 - Lint warning removal */
		{
		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;


	TRACE_FUNCTION("MmiPins:pin_status");

	    SEND_EVENT(pin_data->pin_win,PIN1_STATUS,0,pin_data);
		}
	    return 1;

}



/*******************************************************************************

 $Function:	pin2_fdn_activate 
 $Description:	PIN2 activate fdn    call from menu Settings
 $Returns:		Status int
 $Arguments:	none
*******************************************************************************/
int pin2_fdn_activate (void)
{		T_MFW_HND parent_win = mfwParent( mfw_header() );
		T_MFW_HND win = setting_pin_create(parent_win);
		T_MFW_SIM_PIN_STATUS status;
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;
		
		if(win != NULL) /* x0039928 - Lint warning removal */
		{
		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;
	
	
		pin_data->set_state = FDN_ACTIV;

	TRACE_FUNCTION("MmiPins:pin2_check");

	status.type = MFW_SIM_PIN2;
		sim_pin_status(&status);
		SimHasPin(MFW_SIM_PIN2);

		TRACE_EVENT_P1("PIN2 status is: %d",status.stat);
	       // June 16, 2005  REF: CRR 31267  x0021334
	       // Check if PIN2 and PUK2 are initialised
		if ((sim_pin_count(MFW_SIM_PIN2) > 0) AND (sim_pin_count(MFW_SIM_PUK2) NEQ 0))
		{
			SEND_EVENT(pin_data->pin_win,PIN2_REQ,0,pin_data);
		}
		// If PIN2 is not initialised, ask for PUK 2
		else if ((sim_pin_count(MFW_SIM_PIN2) EQ 0) AND (sim_pin_count(MFW_SIM_PUK2) > 0))
		{
			pin_data->puk_request = TRUE;
			SEND_EVENT(pin_data->pin_win,PUK2_REQ,0,pin_data);
		}
		// Else display that PIN2 is not available
		else
		{
			SEND_EVENT(pin_data->pin_win,PIN2_SIM_FAILURE,0,pin_data);
		}
	}
		return 1;
}
void pin1_not_enabled_screen( void )
{		
	T_MFW_HND	    parent_window	 = mfwParent( mfw_header() );
	T_DISPLAY_DATA display_info; 

	dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, TxtEnablePIN, TxtNull , COLOUR_STATUS);
	dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)not_avail_cb, THREE_SECS, KEY_RIGHT|KEY_LEFT );
	
	info_dialog( parent_window, &display_info );
}

void pin2_not_available_screen( void )
{		
	T_MFW_HND	    parent_window	 = mfwParent( mfw_header() );
	T_DISPLAY_DATA display_info; 

	dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, TxtPin2Code, TxtNotAvailable , COLOUR_STATUS);
	dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)not_avail_cb, THREE_SECS, KEY_RIGHT|KEY_LEFT );
	
	info_dialog( parent_window, &display_info );
}

static void not_avail_cb(T_MFW_HND win, UBYTE identifier, UBYTE reason)
{

		switch (reason)
		{
		case INFO_KCD_LEFT:
		case INFO_KCD_RIGHT:
		
		case INFO_TIMEOUT:
			winShow(win);
			break;
		}
	
}
/*******************************************************************************

 $Function:	pin2_fdn_deactivate
 $Description:	PIN2 deactivate fdn    call from menu Settings
 $Returns:		Status int
 $Arguments:	none
*******************************************************************************/
int pin2_fdn_deactivate (void)
{
		T_MFW_HND parent_win = mfwParent( mfw_header() );
		T_MFW_HND win = setting_pin_create(parent_win);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;
		
		if(win != NULL) /* x0039928 - Lint warning removal */
		{	win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;
//test if sim card has a PIN2
		pin_data->set_state = FDN_DEACTIV;

	TRACE_FUNCTION("MmiPins:pin2_fdn_deactivate");
	       // June 16, 2005  REF: CRR 31267  x0021334
	       // Check if PIN2 and PUK2 are initialised
		if ((sim_pin_count(MFW_SIM_PIN2) > 0) AND (sim_pin_count(MFW_SIM_PUK2) NEQ 0)) //if there is a sim pin2 count
		{
			SEND_EVENT(pin_data->pin_win,PIN2_REQ,0,pin_data);
		}
		//  If PIN2 is not initialised, ask for PUK 2
		else if ((sim_pin_count(MFW_SIM_PIN2) EQ 0) AND (sim_pin_count(MFW_SIM_PUK2) > 0))
		{
			pin_data->puk_request = TRUE;
			SEND_EVENT(pin_data->pin_win,PUK2_REQ,0,pin_data);
		}
		// Else display that PIN2 is not available
		else
		{
			SEND_EVENT(pin_data->pin_win,PIN2_SIM_FAILURE,0,pin_data);
		}
		}
		return 1;
}




/*******************************************************************************

 $Function:	sett_pin_edit
 $Description:	help function for editor dialog
 $Returns:		none
 $Arguments:	window, event
*******************************************************************************/
static void sett_pin_edit(T_MFW_HND win, USHORT event)
{

//open the editor for entering the pin

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	T_MFW_HND pin_edt_win;



	pin_edt_win = set_pin_edt_create(pin_data->pin_win);



    if(pin_edt_win)
	{
		SEND_EVENT(pin_edt_win,event,0,pin_data);
	}
 


}



/*******************************************************************************

 $Function:	set_pin_edt_create
 $Description:	Creation of an instance  for the PIN Editor dialog settings
				Type of dialog : SINGLE_DYNAMIC
 $Returns:		window
 $Arguments:	parent window
*******************************************************************************/
T_MFW_HND set_pin_edt_create (T_MFW_HND parent_window)
{
  T_pin_edt * data = (T_pin_edt *)ALLOC_MEMORY (sizeof (T_pin_edt));
  T_MFW_WIN * win;

  data->pin_edt_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)set_pin_edt_win_cb);

  TRACE_FUNCTION("MmiPins:set_pin_edt_create");

  if (data->pin_edt_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  data->mmi_control.dialog    = (T_DIALOG_FUNC)set_pin_editor;
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_edt_win)->data;
  win->user		      = (void *) data;

  /*
   * Create any other handler
   */

  data->tim_out_handle = tim_create(data->pin_edt_win,TIMEOUT,(T_MFW_CB)pin_edt_tim_out_cb);

/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
  data->editor = ATB_edit_Create(&data->editorPinAttr,0);
#else /* NEW_EDITOR */
  data->editor_handle = edt_create(data->pin_edt_win,&data->editpinAttr,0,0);
#endif /* NEW_EDITOR */
  data->kbd_handle = kbd_create(data->pin_edt_win,KEY_ALL,(T_MFW_CB)set_pin_kbd_cb);
   data->kbd_long_handle = kbd_create(data->pin_edt_win,KEY_ALL | KEY_LONG,(T_MFW_CB)set_pin_edt_kbd_long_cb);
  /*
   * return window handle
   */
  return data->pin_edt_win;
}


/*******************************************************************************

 $Function:	set_pin_edt_destroy
 $Description:	Destroy the pin editor dialog
 $Returns:		none
 $Arguments:	window
*******************************************************************************/
void set_pin_edt_destroy  (T_MFW_HND own_window)
{
  T_pin_edt * data ;
  T_MFW_WIN * win;

  if (own_window)
  {
	  TRACE_FUNCTION("MmiPins:set_pin_edt_destroy");

	  win = ((T_MFW_HDR *)own_window)->data;
	  data = (T_pin_edt *)win->user;

	  if(data)
	  {
      /*
       * Delete WIN Handler
       */
	      win_delete (data->pin_edt_win);
	      FREE_MEMORY((void *)data,(sizeof(T_pin_edt)));
	  }
   }
}

#if(0) /* x0039928 - Lint warning removal */
/*******************************************************************************

 $Function:	set_pin_win_cb 
 $Description:	Callback function for editor windows
 $Returns:		status int
 $Arguments:	event, window
*******************************************************************************/
static int set_pin_win_cb (T_MFW_EVENT event,T_MFW_WIN * win)
{

 TRACE_FUNCTION("set_pin_win_cb");
 if (event EQ MfwWinVisible)
  {

	dspl_ClearAll();
	return 1;
  }
  return 0;
}
#endif

/*******************************************************************************

 $Function:	set_pin_edt_win_cb
 $Description:	Callback function for editor windows
 $Returns:		status int
 $Arguments:	event, window
*******************************************************************************/
static int set_pin_edt_win_cb (T_MFW_EVENT event,T_MFW_WIN * win)
{
  T_pin_edt * edt_data = (T_pin_edt *)win->user;//pin edt data
  T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
  T_pin     * pin_data = (T_pin *)win_pin->user; // pin main data

  TRACE_FUNCTION("set_pin_edt_win_cb");

  if (event EQ MfwWinVisible)
  {
  /* SPR#1428 - SH - New Editor changes */
  #ifdef NEW_EDITOR
	ATB_edit_Show(edt_data->editor);
	
	if (edt_data->editor->update!=ED_UPDATE_TRIVIAL)
	{
		/* Set the colour for drawing title */

		resources_setTitleColour(COLOUR_EDITOR);

		dspl_Clear(0,0, SCREEN_SIZE_X-1, edt_data->editor->attr->win_size.py-1);

		/* Title */

		if(pin_emergency_call == TRUE)
		{					
			PROMPT(0,0,0,TxtEmergency);
		}
		else
		{
		   	PROMPT(0,0,0,pin_data->display_id1);
#ifdef SIM_PERS
			if( pin_data->display_id2)
				PROMPT(0,20,0,pin_data->display_id2);
#endif
		}

		/* Soft keys */
		
		if ((strlen((char*)edt_data->pin) >= MIN_PIN) && (strlen((char*)edt_data->pin) < (MAX_PIN + 1)))
		{
				if(!(edt_data->gsm_state))	  /* usual way for PIN 4 digits     */
				{
#ifdef SIM_PERS
					if(pin_data->display_id1 == TxtPhoneBlocked)
						softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);
					else
#endif
					softKeys_displayId(TxtSoftOK,TxtDelete,0, COLOUR_EDITOR_XX);
				}
			}
		//xvilliva - Added the below "if" and moved the existing "if" in to "else". "if" avoids "delete" key display.
		if((strlen((char*)edt_data->pin) == 0))//  May 13, 2004        REF: CRR 13623  xvilliva
		{
			TRACE_EVENT("clear softkey 16 - zero length");
			softKeys_displayId(TxtNull,TxtNull,0, COLOUR_EDITOR_XX);												
		}
		else if((strlen((char*)edt_data->pin) < MIN_PIN) && (edt_data->emergency_call != TRUE))
		{
			TRACE_EVENT("clear softkey 16");	
			softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);												
		}
#ifdef SIM_PERS
		else if((strlen((char*)edt_data->pin) < MIN_PIN) && (edt_data->emergency_call == TRUE))
		{
			TRACE_EVENT("clear softkey 16");	
			if(pin_emergency_call == TRUE)
				softKeys_displayId(TxtSoftCall,TxtDelete,0, COLOUR_EDITOR_XX);												
			else
			softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);												
		}
#endif
	}
	
	edt_data->editor->update = ED_UPDATE_DEFAULT;
	
#else /* NEW_EDITOR */
	pin_icons();
   	PROMPT(INFO_TEXT_X,INFO_TEXT_Y,0,pin_data->display_id1);
   	
  TRACE_FUNCTION("softkey 6");
	softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);
#endif /* NEW_EDITOR */
    return 1;
  }
  return 0;
}



/*******************************************************************************

 $Function:	set_pin_editor
 $Description:	Pin editor Dialog Signal Handling function
 $Returns:		void
 $Arguments:	window, event, value, parameters
*******************************************************************************/
static void set_pin_editor(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;

    T_pin * pin_data = (T_pin *)parameter;//pin main data

	edt_data->pin_case_edit = pin_data->pin_case;

	TRACE_FUNCTION("MmiPins:set_pin_editor");

  /*
   * depending on event
   */
  switch (event)
  {
	case INPUT_PIN1:
	case INPUT_PIN2:
	case INPUT_PUK1:
	case INPUT_PUK2:
	case INPUT_NEW_PIN:
	case INPUT_NEW_PIN_AGAIN:
	case INPUT_NEW_PIN2:
	case INPUT_NEW_PIN2_AGAIN:
#ifdef SIM_PERS
    case INPUT_SIM_PLOCK:
    case INPUT_SIM_FCPWD:
   case INPUT_NEW_SIM_PLOCK:
    case INPUT_NEW_SIM_PLOCK_AGAIN:
	case PERM_BLK1:
	//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
	case INPUT_SIM_MKPWD:

#endif
 		//SPR#717 - GW - Wrong structures being cleared
		memset(edt_data->pin, '\0', sizeof(edt_data->pin));/* initial string  */
		memset(edt_data->puk, '\0', sizeof(edt_data->puk));
		memset(edt_data->new_pin, '\0', sizeof(edt_data->new_pin));
		memset(edt_data->old_pin, '\0', sizeof(edt_data->old_pin));

		/* Set up pin entry attributes */
		/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
		AUI_edit_SetAttr( &edt_data->editorPinAttr, PIN_EDIT_RESET, COLOUR_EDITOR_XX, EDITOR_FONT, 0, ED_CURSOR_UNDERLINE, ATB_DCS_ASCII, (UBYTE *)edt_data->edtbuf, MAX_DIG);
		clear_edit_array(edt_data);	     /*    clear editor buffer	    */
		edt_data->editor_index = 0;
		ATB_edit_Init(edt_data->editor);
		ATB_edit_Show(edt_data->editor);
#else /* NEW_EDITOR */
		editor_attr_init( &edt_data->editpinAttr, PIN_EDIT_RESET, edtCurBar1,0,(char*)edt_data->edtbuf,MAX_DIG,COLOUR_EDITOR_XX);
		clear_edit_array(edt_data);	     /*    clear editor buffer	    */
		edt_data->editor_index = 0;
		edtShow(edt_data->editor_handle);
#endif /* NEW_EDITOR */

		winShow(edt_data->pin_edt_win);

		break;

	default:
		break;
  }
}



/*******************************************************************************

 $Function:	set_pin_kbd_cb
 $Description:	Callback function for keyboard settings pin
 $Returns:		status int
 $Arguments:	event, keyboard control block
*******************************************************************************/
static int set_pin_kbd_cb (T_MFW_EVENT event,T_MFW_KBD *  kc)
{
    T_MFW_HND win = mfw_parent(mfw_header());
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;

	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;//pin edt data

	T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
	T_pin * pin_data = (T_pin *)win_pin->user; // pin main data

	char timer = TRUE;

	timStop(edt_data->tim_out_handle);/* stop entering timer      */

	TRACE_FUNCTION("MmiPins:set_pin_kbd_cb");

#ifdef SIM_PERS
	if( !perm_blocked)
#endif
	{
	switch(kc->code)
	{
		case KCD_0:
		case KCD_1:
		case KCD_2:
		case KCD_3:
		case KCD_4:
		case KCD_5:
		case KCD_6:
		case KCD_7:
		case KCD_8:
		case KCD_9:
		case KCD_STAR:
			if(edt_data->editor_index < MAX_DIG)
			{
				/* xreddymn OMAPS00083495 Jul-04-2006 
				 * Limit PIN1, PIN2 entries to 8 digits.
				 */
				if(((edt_data->pin_case_edit==INPUT_PIN1) || 
					(edt_data->pin_case_edit==INPUT_PIN2) ||
					(edt_data->pin_case_edit==INPUT_NEW_PIN) ||
					(edt_data->pin_case_edit==INPUT_NEW_PIN_AGAIN) ||
					(edt_data->pin_case_edit==INPUT_NEW_PIN2) ||
					(edt_data->pin_case_edit==INPUT_NEW_PIN2_AGAIN)) &&
					(edt_data->editor_index>=8) && 
					(!edt_data->gsm_state))

					return MFW_EVENT_CONSUMED;
				else
				{
					if(kc->code EQ KCD_STAR)
						edt_data->pin[edt_data->editor_index] = STAR;
					else
						edt_data->pin[edt_data->editor_index] = '0' + kc->code;

					/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
					ATB_edit_AsciiChar(edt_data->editor, '*', TRUE);
#else /* NEW_EDITOR */
					edtChar(edt_data->editor_handle,'*');/* hide security code */
#endif /* NEW_EDITOR */

					edt_data->editor_index++;
					check_set_pins(win,edt_data); /* digits check depends on status pin_case */
					if(edt_data->gsm_state)
						pin_data->gsm_state = edt_data->gsm_state;
				}
			}
			winShow(edt_data->pin_edt_win);
			break;

		case KCD_HASH:
		case KCD_LEFT:

			if(pin_emergency_call == TRUE)
			{
				callNumber((UBYTE *)pin_emerg_call);
				pin_emergency_call = FALSE;
			}

			/* If it's a hash, insert it into the editor */
			
			// change by Sasken ( Rashmi C N) on March 25th 2004
			// Issue Number : MMI-SPR-15692
			// Subject: Wrong entry in last dialed number.
			// Bug : While saving PIN, if a hash is entered as a 
			// delimiter/terminater, the hash is also getting stored 
			// as  a part of pin. This makes it mandatory for the user 
			// to enter hash as delimiter/terminater while he is authenticating.
			// Solution: Avoid copying the hash(delimiter/terminater) in to the pin array.
			//			 Commenting the copying part below in the "if" block.
			
			// If it's a hash, insert it into the editor 
			//if(kc->code EQ KCD_HASH)
			//xrashmic 1 Jul, 2006 OMAPS00075784
			//To fix the reset while entering the gsm sequence for unblocking 
			// the pin1 or pin2
			if(!(strncmp((char*)edt_data->pin,"**052*",IDENT_GSM_2))||!(strncmp((char*)edt_data->pin,"**05*",IDENT_GSM_1)))

			{
				edt_data->pin[edt_data->editor_index] = HASH;
				// SPR#1428 - SH - New Editor changes 
#ifdef NEW_EDITOR
				ATB_edit_AsciiChar(edt_data->editor, edt_data->pin[edt_data->editor_index], TRUE);
#else // NEW_EDITOR 
				edtChar(edt_data->editor_handle,edt_data->pin[edt_data->editor_index]);
#endif // NEW_EDITOR 
				edt_data->editor_index++;
			}

			

			// We save the pin2 entered in to this global variable which we
			// use while calling sAT_PlusCLCK(), while locking or unlocking ALS. 					
			memset(g_pin2,0,MAX_PIN+1);
			if(edt_data->pin_case_edit EQ INPUT_PIN2 || edt_data->pin_case_edit EQ INPUT_NEW_PIN2)
				strncpy(g_pin2,(char*)edt_data->pin,MAX_PIN);//xvilliva SPR17291
			switch(edt_data->pin_case_edit)
			{
#ifdef SIM_PERS                
                case INPUT_SIM_PLOCK:
             	  case  INPUT_SIM_FCPWD:
		//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		  case INPUT_SIM_MKPWD:
                		
#endif                            
			/* PIN1 and PIN2 */
				case INPUT_PIN1:/* finish of PIN entering */
				case INPUT_PIN2:
					TRACE_EVENT_P1("pin_emergency_call = %d", pin_emergency_call);
					TRACE_EVENT("When 'Call' is pressed!");

					/* PIN is long enough, finish editing */
					
					if ((strlen((char*)edt_data->pin) >= MIN_PIN)  && !(edt_data->gsm_state))
					{
						clear_edit_array(edt_data);	    /*	   clear editor array */
						timer = FALSE;
						strncpy((char*)edt_data->old_pin,(char*)edt_data->pin,MAX_PIN);
						strncpy((char*)pin_data->old_pin, (char*)edt_data->old_pin,MAX_PIN);
						if(edt_data->pin_case_edit EQ INPUT_PIN1)
						{
						    set_pin_edt_destroy(edt_data->pin_edt_win);
							SEND_EVENT(pin_data->pin_win,PIN1_END,0,pin_data);
						}

#ifdef SIM_PERS                        
                         			else if(edt_data->pin_case_edit EQ INPUT_SIM_PLOCK)
                         			{
						    set_pin_edt_destroy(edt_data->pin_edt_win);
							SEND_EVENT(pin_data->pin_win,SIM_PLOCK_END,0,pin_data);
						}

		                         	else if(edt_data->pin_case_edit EQ INPUT_SIM_FCPWD)
                         			{
						    set_pin_edt_destroy(edt_data->pin_edt_win);
							SEND_EVENT(pin_data->pin_win,SIM_FCPWD_END,0,pin_data);
						}
						//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
						else if(edt_data->pin_case_edit EQ INPUT_SIM_MKPWD)
                         			{
						    set_pin_edt_destroy(edt_data->pin_edt_win);
							SEND_EVENT(pin_data->pin_win,SIM_MKPWD_END,0,pin_data);
						}	  
                         
#endif
						else
						{
						    set_pin_edt_destroy(edt_data->pin_edt_win);
							SEND_EVENT(pin_data->pin_win,PIN2_END,0,pin_data);
						}
					}
					else
					{
						if(kc->code EQ KCD_HASH)
						{	
							if (!(edt_data->gsm_state))	/* could become gsm */
							{
								check_pins(win,edt_data);
								if(edt_data->gsm_state)
									pin_data->gsm_state = edt_data->gsm_state;
							}
							else /* finish gsm string */
							{
								timer = FALSE;
								if(edt_data->pin_case_edit EQ INPUT_PIN1)
									pin_data->pin_case = PIN1_REQ_OLD;
								else
									pin_data->pin_case = PIN2_REQ_OLD;
								//xrashmic 1 Jul, 2006 OMAPS00075784
								//Blue screen fix - Wrong window was being sent
								gsm_sec_execute_set(pin_data->pin_win,edt_data);	    /* execute gsm string */

							}
						}
					}
					break;

				/* PUK1 and PUK2 */
				
				case INPUT_PUK1:
				case INPUT_PUK2:
					if ((strlen((char*)edt_data->pin) >= MIN_PIN) && !(edt_data->gsm_state)) /* finish of PUK entering */
					{
						clear_edit_array (edt_data);		/* clear editor array */
						timer = FALSE;
						strncpy((char*)edt_data->puk,(char*)edt_data->pin,MAX_PIN);/* store puk  */
						strncpy((char*)pin_data->puk, (char*)edt_data->puk,MAX_PIN);
						if( pin_data->pin_case EQ INPUT_PUK1) 
						{
							    set_pin_edt_destroy(edt_data->pin_edt_win);
								SEND_EVENT(pin_data->pin_win,INPUT_NEW_PIN,0,pin_data);/* entering new pin1 start*/
						}
						else
						{
						    set_pin_edt_destroy(edt_data->pin_edt_win);
							SEND_EVENT(pin_data->pin_win,INPUT_NEW_PIN2,0,pin_data);/* entering new pin2 start*/
						}
					}
					else
					{
						if(kc->code EQ KCD_HASH)
						{		
							if (!(edt_data->gsm_state))/* could become gsm	    */
							{
								check_pins(win,edt_data);
								if(edt_data->gsm_state)
									pin_data->gsm_state = edt_data->gsm_state;
							}
							else /* finish gsm string  */
							{
								timer = FALSE;
								//xrashmic 1 Jul, 2006 OMAPS00075784
								//Blue screen fix - Wrong window was being sent
								gsm_sec_execute_set(pin_data->pin_win,edt_data);	    /* execute gsm string */

							}
						}
					}
					break;
					
				case INPUT_NEW_PIN:
				case INPUT_NEW_PIN2:

		#ifdef SIM_PERS
                            case INPUT_NEW_SIM_PLOCK:
                #endif
					if ((strlen((char*)edt_data->pin) >= MIN_PIN)  && !(edt_data->gsm_state))
					{
						clear_edit_array (edt_data);			  /* clear editor array */
						timer = FALSE;
						strncpy((char*)edt_data->new_pin, (char*)edt_data->pin,MAX_PIN);	  /*  store new pin	  */
						strncpy((char*)pin_data->new_pin, (char*)edt_data->new_pin,MAX_PIN);
						if(pin_data->pin_case EQ INPUT_NEW_PIN )
						{
						    set_pin_edt_destroy(edt_data->pin_edt_win);       /* entering new pin1 again*/
							SEND_EVENT(pin_data->pin_win,INPUT_NEW_PIN_AGAIN,0,pin_data);
						}
					
				#ifdef SIM_PERS
			             		else if(pin_data->pin_case EQ INPUT_NEW_SIM_PLOCK)
                                       	{
                                           	set_pin_edt_destroy(edt_data->pin_edt_win);
                                           	SEND_EVENT(pin_data->pin_win,INPUT_NEW_SIM_PLOCK_AGAIN,0,pin_data);
                                         }
	                    #endif
						else
						{
						    set_pin_edt_destroy(edt_data->pin_edt_win);       /* entering new pin1 again*/
							SEND_EVENT(pin_data->pin_win,INPUT_NEW_PIN2_AGAIN,0,pin_data);
						}
					}
					else
					{
						if(kc->code EQ KCD_HASH)
						{	
							if(!(edt_data->gsm_state)) /* could become gsm	    */
							{
								check_pins(win,edt_data);
								if(edt_data->gsm_state)
						       		pin_data->gsm_state = edt_data->gsm_state;
							}
							else /* finish gsm string  */
							{
								timer = FALSE;

								if(edt_data->pin_case_edit EQ INPUT_NEW_PIN)
									pin_data->pin_case = PIN1_REQ_OLD;
								else
									pin_data->pin_case = PIN2_REQ_OLD;
								//xrashmic 1 Jul, 2006 OMAPS00075784
								//Blue screen fix - Wrong window was being sent
								gsm_sec_execute_set(pin_data->pin_win,edt_data);	    /* execute gsm string */

							}
						}
					}
					break;

	#ifdef SIM_PERS
                            case INPUT_NEW_SIM_PLOCK_AGAIN:
       #endif						
				case INPUT_NEW_PIN_AGAIN:
				case INPUT_NEW_PIN2_AGAIN:
						if ((strlen((char*)edt_data->pin) >= MIN_PIN) && !(edt_data->gsm_state))
						{
							clear_edit_array (edt_data);			  /* clear editor array */
							timer = FALSE;
							if(strcmp((char*)edt_data->pin, (char*)pin_data->new_pin) EQ 0) /* compare PINs successfull*/
							{
								strncpy((char*)pin_data->new_pin, (char*)edt_data->pin,MAX_PIN);
								if(pin_data->pin_case EQ INPUT_NEW_PIN_AGAIN)
								{
								    set_pin_edt_destroy(edt_data->pin_edt_win);
									SEND_EVENT(pin_data->pin_win,NEW_PIN_END,0,pin_data);/* changing PIN1 */
								}
						#ifdef SIM_PERS
                                                		else if (pin_data->pin_case EQ INPUT_NEW_SIM_PLOCK_AGAIN)
                                                   	{
                                                     		set_pin_edt_destroy(edt_data->pin_edt_win);
                                                    		SEND_EVENT(pin_data->pin_win, NEW_SIM_PLOCK_END,0,pin_data);
                                                   	}
          					#endif
								else
								{
								    set_pin_edt_destroy(edt_data->pin_edt_win);
									SEND_EVENT(pin_data->pin_win,NEW_PIN2_END,0,pin_data);/* changing PIN2 */
								}
							}
							else
							{									/* new PIN != new PIN again */

								if(pin_data->pin_case EQ INPUT_NEW_PIN_AGAIN)
								{
									set_pin_edt_destroy(edt_data->pin_edt_win);
									SEND_EVENT(pin_data->pin_win,NEW_PIN_FAIL,0,NULL);
								}
						#ifdef  SIM_PERS  
								else if(pin_data->pin_case EQ INPUT_NEW_SIM_PLOCK_AGAIN)
								{
                                        				set_pin_edt_destroy(edt_data->pin_edt_win);
                                        				SEND_EVENT(pin_data->pin_win,NEW_SIM_PLOCK_FAIL,0,NULL);
                                 				}
                                        #endif		
								else
								{
									set_pin_edt_destroy(edt_data->pin_edt_win);
									SEND_EVENT(pin_data->pin_win,NEW_PIN2_FAIL,0,NULL);
								}
							}
						}
						else
						{
							if(kc->code EQ KCD_HASH)
							{
								if (!(edt_data->gsm_state)) /* could become gsm	    */
								{
									check_pins(win,edt_data);
									if(edt_data->gsm_state)
							       		pin_data->gsm_state = edt_data->gsm_state;
								}
								else /* finish gsm string  */
								{
									timer = FALSE;
									if(edt_data->pin_case_edit EQ INPUT_NEW_PIN_AGAIN)
										pin_data->pin_case = PIN1_REQ_OLD;
									else
										pin_data->pin_case = PIN2_REQ_OLD;
								//xrashmic 1 Jul, 2006 OMAPS00075784
								//Blue screen fix - Wrong window was being sent
								gsm_sec_execute_set(pin_data->pin_win,edt_data);	    /* execute gsm string */

								}
							}
						}
						break;
					
					default:
						break;
				}
				break;
				
/* KCD_HUP */
			case KCD_HUP:
				if( edt_data->pin_case_edit != INPUT_PUK1)//xvilliva SPR13623
				{
				clear_edit_array(edt_data);
				timer = FALSE;
				set_pin_edt_destroy(edt_data->pin_edt_win);
	    		SEND_EVENT(pin_data->pin_win,SETT_ABORT,0,NULL); // abort settings menu
				}
				break;

/* KCD RIGHT */

			case KCD_RIGHT: 	
			//nm, go back to the submenu if there is no character on the screen
				if(strlen((char*)edt_data->pin) == 0 && edt_data->pin_case_edit != INPUT_PUK1)//xvilliva SPR13623
				{
					clear_edit_array(edt_data);
					timer = FALSE;
					set_pin_edt_destroy(edt_data->pin_edt_win);
		    		SEND_EVENT(pin_data->pin_win,SETT_ABORT,0,NULL); // abort settings menu
					return 1;			    
				}

				if(edt_data->editor_index EQ 0)
					;
				else
					edt_data->editor_index--;

				edt_data->pin[edt_data->editor_index] = '\0';
				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				ATB_edit_DeleteLeft(edt_data->editor, TRUE); /* SPR#2342 - SH */
#else /* NEW_EDITOR */
				edtChar(edt_data->editor_handle,ecBack);/* delete character    */
#endif /* NEW_EDITOR */

				if(strlen((char*)edt_data->pin)<MIN_PIN)
				{
				}

				edt_data->emergency_call = FALSE;
				if(edt_data->pin_case_edit EQ INPUT_PUK1)  /* special case ?? */
					winShow(edt_data->pin_edt_win);
				else
				{
					check_set_pins(win,edt_data);	       /* check remain for emergency call  */
					winShow(edt_data->pin_edt_win);
				}
			    break;
			    
			default:
				break;
		}
	}
#ifdef SIM_PERS
	else
	{
		switch(kc->code)
		{
		case KCD_0:
		case KCD_1:
		case KCD_2:
		case KCD_6:
		case KCD_8:
		case KCD_9:
			if(edt_data->editor_index < MAX_DIG)
			{
				edt_data->pin[edt_data->editor_index] = '0' + kc->code;

				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				ATB_edit_AsciiChar(edt_data->editor, '*', TRUE);
#else /* NEW_EDITOR */
				edtChar(edt_data->editor_handle,'*');/* hide security code */
#endif /* NEW_EDITOR */

				edt_data->editor_index++;
				check_set_pins(win,edt_data); /* digits check depends on status pin_case */
				if(edt_data->gsm_state)
					pin_data->gsm_state = edt_data->gsm_state;
			}
			winShow(edt_data->pin_edt_win);
			break;
				
	
		case KCD_LEFT:

			if(pin_emergency_call == TRUE)
			{
				callNumber((UBYTE *)pin_emerg_call);
				pin_emergency_call = FALSE;
			}
			break;

		case KCD_RIGHT: 	

//				if( edt_data->edtbuf == '\0' )
//					break;
				if(edt_data->editor_index EQ 0)
					;
				else
					edt_data->editor_index--;

				edt_data->pin[edt_data->editor_index] = '\0';
				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				ATB_edit_DeleteLeft(edt_data->editor, TRUE); /* SPR#2342 - SH */
#else /* NEW_EDITOR */
				edtChar(edt_data->editor_handle,ecBack);/* delete character    */
#endif /* NEW_EDITOR */

				if(strlen((char*)edt_data->pin)<MIN_PIN)
				{
				}

				edt_data->emergency_call = FALSE;
				if(edt_data->pin_case_edit EQ INPUT_PUK1)  /* special case ?? */
					winShow(edt_data->pin_edt_win);
				else
				{
					check_set_pins(win,edt_data);	       /* check remain for emergency call  */
					winShow(edt_data->pin_edt_win);
				}
			    break;

			default:
				break;
			}	
	}
#endif /* SIM_PERS */
	if (timer)
		tim_start(edt_data->tim_out_handle);/* start timer for entering */
	return 1;
}



/*******************************************************************************

 $Function:	set_pin_edt_kbd_long_cb
 $Description:	Callback function for keyboard long
 $Returns:		status int
 $Arguments:	event, keyboard control block
*******************************************************************************/
static int set_pin_edt_kbd_long_cb (T_MFW_EVENT event,T_MFW_KBD *  kc)
{
    T_MFW_HND win = mfw_parent(mfw_header());

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;//pin edt data

    TRACE_FUNCTION("MmiPins:set_pin_edt_kbd_long_cb");

    if ((event & KEY_CLEAR) && (event & KEY_LONG))
	{
			timStop(edt_data->tim_out_handle); /* stop entering timer	*/
			clear_edit_array(edt_data);
			memset(edt_data->pin,'\0',sizeof(edt_data->pin));/* initial string */
			
			/* SPR#1428 - SH - New Editor: string changed, update word-wrap*/
	#ifdef NEW_EDITOR
			ATB_edit_Refresh(edt_data->editor);
	#endif /* NEW_EDITOR */
			edt_data->editor_index = 0;
			edt_data->emergency_call = FALSE;
			winShow(edt_data->pin_edt_win);
	}

  return MFW_EVENT_CONSUMED;
}

/*******************************************************************************

 $Function:	check_set_pins 
 $Description:	check input string for settings
 $Returns:		void
 $Arguments:	window pin editor attributes
*******************************************************************************/
static void check_set_pins (T_MFW_HND win,void * edt_pin)
{
	T_pin_edt * edt_data = (T_pin_edt *)edt_pin;

	TRACE_FUNCTION("MmiPins: check_set_pins");

	if(strlen((char*)edt_data->pin)NEQ 0)
    {
	    if (strlen((char*)edt_data->pin) > FIRST_DIGIT)	 /* for every character  */
			gsm_set_test(win,edt_data);	/* test if GSM string or not*/
		/*API - 10/10/02 - 1162 - check the value entered into the PIN editor to see if the 
								  value being entered in is an emergency number.
		*/
		if (strlen((char*)edt_data->pin) EQ (MIN_PIN - 1) || strlen((char*)edt_data->pin) EQ (MIN_PIN -2))
		{
			TRACE_FUNCTION("cm_check_emergency() TRACE PINS 1");
			if(cm_check_emergency((U8*)edt_data->pin))/* test emergency call*/
			{
				edt_data->emergency_call = TRUE;
				pin_emergency_call = TRUE;
				memset(pin_emerg_call, '\0',sizeof(pin_emerg_call));
				strcpy((char *)pin_emerg_call, (char *)edt_data->pin);
			}
			else
			{
// Nov 24, 2005, a0876501, DR: OMAPS00045909
				if((edt_data->pin_case_edit EQ CARD_REJECTED) OR (edt_data->pin_case_edit EQ INSERT_CARD)
					OR (edt_data->pin_case_edit EQ SHOW_IMEI_INVALID)				
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS	
					//x0pleela 30 Aug, 2006 DR: OMAPS00091250
					OR(edt_data->pin_case_edit EQ NO_MEPD_DATA)
#endif					
					)
				{			  /* delete all digits	    */
					clear_edit_array (edt_data);  /*  clear editor array	 */
					memset(edt_data->pin, '\0', sizeof(edt_data->pin));/* initial string */
					edt_data->editor_index = 0;
				}
				edt_data->emergency_call = FALSE;
				pin_emergency_call = FALSE;
			}
		}
		else
		{
// Nov 24, 2005, a0876501, DR: OMAPS00045909
			if((edt_data->pin_case_edit EQ CARD_REJECTED) OR (edt_data->pin_case_edit EQ INSERT_CARD)
				OR (edt_data->pin_case_edit EQ SHOW_IMEI_INVALID)				
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS					
				//x0pleela 30 Aug, 2006 DR: OMAPS00091250
				OR (edt_data->pin_case_edit EQ NO_MEPD_DATA)
#endif				
				)
			{			  /* delete all digits	    */
				clear_edit_array (edt_data);  /*  clear editor array	 */
				memset(edt_data->pin, '\0', sizeof(edt_data->pin));/* initial string */
				edt_data->editor_index = 0;
			}
			edt_data->emergency_call = FALSE;
			pin_emergency_call = FALSE;
		}
		/*SPR 2145, if entering PIN1, then make sure no more than 8 characters are entered*/
		if(((strlen((char*)edt_data->pin) > MAX_PIN) || /*no more than 16 digits allowed*/
			(edt_data->pin_case_edit EQ INPUT_PIN1 && strlen((char*)edt_data->pin) > MAX_PIN_EN_DIS ))/*PIN1 should be no more than 8 digits*/
			&& !(edt_data->gsm_state)) /*allowed up to 30 digits if entering GSM string*/
		{

			if(edt_data->editor_index EQ 0)
				;
			else
				edt_data->editor_index--;

			edt_data->pin[edt_data->editor_index] = '\0';

			/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
			ATB_edit_DeleteLeft(edt_data->editor, TRUE); /* SPR#2342 - SH */
#else /* NEW_EDITOR */
			edtChar(edt_data->editor_handle,ecBack);/* delete character    */
#endif /* NEW_EDITOR */
		}
	}
}



/*******************************************************************************

 $Function:	sett_pin_mess 
 $Description:	help function for message dialog
 $Returns:		void
 $Arguments:	window, event
*******************************************************************************/
static void sett_pin_mess(T_MFW_HND win,USHORT event)
{

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	T_MFW_HND pin_mess_win;
	TRACE_FUNCTION("MmiPins:sett_pin_mess");

	pin_mess_win = set_pin_mess_create(pin_data->pin_win);
	if(pin_mess_win)
	{
		SEND_EVENT(pin_mess_win,event,0,pin_data);
	}
}


/*******************************************************************************

 $Function:	set_pin_mess_create
 $Description:	Creation of an instance  for the PIN Message dialog settings
				Type of dialog : SINGLE_DYNAMIC
 $Returns:		void
 $Arguments:	parent window
*******************************************************************************/
T_MFW_HND set_pin_mess_create(T_MFW_HND parent_window)
{
  T_pin_mess * data = (T_pin_mess *)ALLOC_MEMORY (sizeof (T_pin_mess));
  T_MFW_WIN	* win;

  data->pin_mess_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)set_pin_mess_win_cb);

  TRACE_FUNCTION("MmiPins: set_pin_mess_create");

  if (data->pin_mess_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  data->mmi_control.dialog    = (T_DIALOG_FUNC)set_pin_messages;
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_mess_win)->data;
  win->user		      = (void *) data;

  /*
   * return window handle
   */
  return data->pin_mess_win;
}


/*******************************************************************************

 $Function:	set pin_mess_destroy
 $Description:	Destroy the pin message dialog settings
 $Returns:		void
 $Arguments:	window
*******************************************************************************/
void set_pin_mess_destroy  (T_MFW_HND own_window)
{
  T_pin_mess * data;
  T_MFW_WIN * win;


  TRACE_FUNCTION("MmiPins: set_pin_mess_destroy");

  if (own_window)
  {
	  win = ((T_MFW_HDR *)own_window)->data;
	  data = (T_pin_mess *)win->user;

	  if(data)
	  {

      /*
       * Delete WIN Handler
       */
	  win_delete (data->pin_mess_win);
	      FREE_MEMORY((void*)data,(sizeof(T_pin_mess)));
	  }
   }
}


/*******************************************************************************

 $Function:	set_pin_mess_win_cb
 $Description:	Callback function for message windows
 $Returns:		void
 $Arguments:	event, window
*******************************************************************************/
static int set_pin_mess_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
  /*
   * Top Window has no output
   */
  return 1;
}


/*******************************************************************************

 $Function:	set_pin_messages
 $Description:	Message Dialog for PIN/PUK handling in settings
 $Returns:		void
 $Arguments:	win, event, value, parameter
*******************************************************************************/
void set_pin_messages(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_mess * mess_data = (T_pin_mess *)win_data->user;

	T_DISPLAY_DATA display_info;

//    U8 uMode;   /* Warning Correction */
	
	T_MFW_SIM_PIN_STATUS status; //need to check the Pin 1 status
	
	T_pin * pin_data = (T_pin *)parameter;
#ifdef SIM_PERS
T_MFW status1 = 0, status2;
  int max=0,max1=0;
	int curr= 0,curr1=0;
#endif
  TRACE_FUNCTION("Mmi.Pins:set_pin_messages");

  /*
   * depending on signal
   */
	
  switch (event)
  {
	case PIN1_REQ_ATT:
	case PIN2_REQ_ATT:
	case PUK1_REQ_VER_INFO:
	case GSM_FAIL:
	case NEW_PIN_FAIL:
	case NEW_PIN2_FAIL:
	case PIN_OK_INFO:
	case PIN1_CH_SUCC:
	case PIN2_CH_SUCC:
	case PUK1_UNBL_FAIL_INFO:
	case PUK1_UNBL_SUCC:
	case PUK1_UNBL_FATAL_ERROR:
	case PIN1_ENAB_END:
	case PIN1_DISAB_END:
	case PIN1_ENDIS_FAIL:
#ifdef SIM_PERS     
    	case SIM_LOCK_ENDIS_FAIL:
      	case SIM_LOCK_ENDSUCC:
       case SIM_LOCK_FCPWD_FAIL:
       case SIM_LOCK_FCPWDSUCC:
	case SIM_LOCK_STATUS:
    	case NEW_SIM_PLOCK_FAIL:
    	case SIM_LOCK_NEW_ENDSUCC:
    	case SIM_LOCK_NEW_ENDISFAIL:
    	case SIM_LOCK_NEW_ENDSUCC_CKEY:	
    	case SIM_LOCK_ALREADY_ENDIS:
    	case SIM_LOCK_SIM_REM:
	case SMLK_SHOW_FC_FAIL1:	
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
       case SIM_LOCK_MKPWD_FAIL:	//Master unlock failed
       case SIM_LOCK_MKPWDSUCC:	//Master unlock success
       case SIM_LOCK_BUSY:			//Category unlock return with Busy error from ACI
       //x0pleel 26 July, 2006 ER: OMAPS00087586, OMAPS00087587
       case SIM_LOCK_BUSY_UNBLOCK: //ME unblock return Busy error from aCI
#endif       
	case FDN_FAIL:
	case FDN_ACT_END:
	case FDN_DEACT_END:
	case PIN1_STATUS:
	case PIN2_SIM_FAILURE:      // Marcus: Issue 1609: 23/01/2003 - failure to verify PIN2


		dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, TxtNull, TxtNull,  COLOUR_STATUS_PINS);
		
		switch(event)
		{
		   case PIN1_REQ_ATT:
			  pin_data->pin_case = PIN1_REQ_OLD;
			  display_info.TextId = TxtPINFail;
			  if(pin_data->pin_retries EQ 1)
				display_info.TextId2 = TxtOneAttemptLeft;
			  else
				display_info.TextId2 = TxtTwoAttemptsLeft;
			  break;
		   case PIN2_REQ_ATT:
			  pin_data->pin_case = PIN2_REQ;
			  display_info.TextId = TxtPINFail;
			  if(pin_data->pin_retries EQ 1)
				display_info.TextId2 = TxtOneAttemptLeft;
			  else
				display_info.TextId2 = TxtTwoAttemptsLeft;
			  break;
		   case PIN1_CH_SUCC:
			  pin_data->pin_case = PIN1_CH_END;
			  display_info.TextId = TxtChangPin;
			  break;
		   case PIN2_CH_SUCC:
			  pin_data->pin_case = PIN2_CH_END;
			  display_info.TextId = TxtChangPIN2;
			  break;
#ifdef SIM_PERS
		  case SIM_LOCK_NEW_ENDSUCC:
           		  pin_data->pin_case = SIM_LOCK_NEW_ENDSUCC;
			  display_info.TextId = TxtPsLockChanged;
			  break;
			  
		  case SIM_LOCK_ENDSUCC:
		  	  pin_data->pin_case = SIM_LOCK_ENDSUCC;
			  if(pin_data->set_state == ENABLE)
			  	display_info.TextId = TxtLockActivated;
			  else if(pin_data->set_state == DISABLE)
			  	display_info.TextId = TxtLockDeactivated;
			  break;	

		  case SIM_LOCK_ALREADY_ENDIS:
		  	  pin_data->pin_case = SIM_LOCK_ALREADY_ENDIS;
			  if(pin_data->set_state == ENABLE)
			  	display_info.TextId = TxtAlreadyLocked;
			  else if(pin_data->set_state == DISABLE)
			  	display_info.TextId = TxtAlreadyUnlocked;
			  break;	
		
		case SIM_LOCK_NEW_ENDSUCC_CKEY:
			 {
				char buf1[20], buf2[20] ;
				int curr_fail_reset, curr_succ_reset;
				TRACE_FUNCTION("BMI:SIM_LOCK_NEW_ENDSUCC_CKEY");
				mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
				pin_data->pin_case = SIM_LOCK_NEW_ENDSUCC_CKEY;
				sprintf((char*)buf1,"%d attempts left",curr_succ_reset);
				sprintf((char*)buf2,"%s", "FC Reset-Success");								
				display_info.TextString= buf1;
				display_info.TextString2 = buf2;
			 }
			  break;

		case SMLK_SHOW_FC_FAIL1:
			  {
				char buf1[20], buf2[20] ;
				int curr_fail_reset, curr_succ_reset;
				mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
				pin_data->pin_case = PUK1_REQ;
				sprintf((char*)buf1,"%d attempts left",curr_fail_reset);
				sprintf((char*)buf2,"%s", "FC Reset-Failure");								
				display_info.TextString= buf1;
				display_info.TextString2 = buf2;
				  break;
			  }

          case SIM_LOCK_FCPWDSUCC:
			 {
				char buf1[20], buf2[20] ;
				int curr_fail_reset, curr_succ_reset;
				mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
				sprintf((char*)buf1,"%d attempts left",curr_succ_reset);
				sprintf((char*)buf2,"%s", "FC Reset-Success");								
				display_info.TextString= buf2;
				display_info.TextString2 = buf1;
			 }
			  	break;			  	

		//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
		//Displays a dialog saying "master unlock success"
          	case SIM_LOCK_MKPWDSUCC:
			 {
			 	char buf1[25];
				sprintf((char*)buf1,"%s"," Master Unlock Success");
				display_info.TextString= buf1;
				display_info.TextString2 = 0;
			 }
			  	break;	
#endif

		   case PUK1_REQ_VER_INFO:
			  if((pin_data->set_state EQ CHANGE_PIN2) ||
				 (pin_data->set_state EQ PIN2_CHECK) ||
				  (pin_data->set_state EQ FDN_ACTIV) ||
				  (pin_data->set_state EQ FDN_DEACTIV))
			  {
					pin_data->pin_case = PUK2_REQ;
			  }
			  else
			  {
					pin_data->pin_case = PUK1_REQ;
			  }
			  display_info.TextId =TxtPINBlock;
			  break;
			  
			case GSM_FAIL:
			  if(pin_data->set_state EQ IDLE_GSM)
				  pin_data->pin_case = IDLE_GSM_FAIL;
			  display_info.TextId = TxtNotAcc;
			  break;   
		}
		 switch(event)
		 {
		   case PUK1_UNBL_FATAL_ERROR:
			  if((pin_data->set_state EQ CHANGE_PIN2) ||
				 (pin_data->set_state EQ FDN_ACTIV) ||
				 (pin_data->set_state EQ FDN_DEACTIV))
			  {
					pin_data->pin_case = PUK2_REQ;
			  }
			  else if(pin_data->set_state == IDLE_GSM)
				  pin_data->pin_case = IDLE_GSM_FAIL;
			  else
			  {
					pin_data->pin_case = PUK1_REQ;
			  }
			  display_info.TextId = TxtNotAcc;
			  break;
		   case NEW_PIN_FAIL:
			pin_data->pin_case = INPUT_NEW_PIN;
			 display_info.TextId = TxtNewPIN;
			  display_info.TextId2 = TxtCodeInc;
			 break;
		   case NEW_PIN2_FAIL:
			 pin_data->pin_case = INPUT_NEW_PIN2;
			 display_info.TextId = TxtNewPIN2;
			 display_info.TextId2 = TxtCodeInc;
			 break;
		   case PIN_OK_INFO:
			TRACE_FUNCTION("PIN_OK_INFO");
			  pin_data->pin_case = PIN_OK;
			  display_info.TextId = TxtPINOK;
			  break;		   
			case PUK1_UNBL_FAIL_INFO:
			  if((pin_data->set_state EQ CHANGE_PIN2) ||
				 (pin_data->set_state EQ PIN2_CHECK) ||
				  (pin_data->set_state EQ FDN_ACTIV) ||
				  (pin_data->set_state EQ FDN_DEACTIV))
			  {
					pin_data->pin_case = PUK2_REQ;

			  }
			  else if(pin_data->set_state EQ IDLE_GSM)
			  {
					pin_data->pin_case = IDLE_GSM_FAIL;

			  }
			  else
			  {
					pin_data->pin_case = PUK1_REQ;

			  }

			  display_info.TextId2 = TxtCodeInc;

			  break;
			case PUK1_UNBL_SUCC:
			  if((pin_data->set_state EQ CHANGE_PIN2) ||
				 (pin_data->set_state EQ PIN2_CHECK) ||
				  (pin_data->set_state EQ FDN_ACTIV) ||
				  (pin_data->set_state EQ FDN_DEACTIV))
				display_info.TextId = TxtNewPIN2;
			  else
				display_info.TextId = TxtNewPIN;
			  pin_data->pin_case = UNBL_OK;    
			  display_info.TextId2 = TxtChanged;
			  break;
			case PIN1_ENAB_END:
			  pin_data->pin_case = UNBL_OK;
			  pin_data->set_state = DEFAULT;
			display_info.TextId = TxtPinCode;
			  display_info.TextId2 = TxtActivated;
			  break;
			case PIN1_DISAB_END:
			  pin_data->pin_case = UNBL_OK;
			  pin_data->set_state = DEFAULT;
			  display_info.TextId = TxtPinCode;
			  display_info.TextId2 = TxtDeActivated;
			  break;
			case FDN_ACT_END:
			  pin_data->pin_case = FDN_UNBL_OK;
			  display_info.TextId = TxtActivated;
			  break;
			case FDN_DEACT_END:
			  pin_data->pin_case = FDN_UNBL_OK;
			  display_info.TextId = TxtDeActivated;
			  break;
			case FDN_FAIL:
			  pin_data->pin_case = UNBL_OK;
			  display_info.TextId = TxtFailed;
			  break;
			case PIN1_ENDIS_FAIL:
			  pin_data->pin_case = PIN1_REQ;
			  display_info.TextId = TxtPINFail;
			  if(pin_data->pin_retries EQ 1)
				display_info.TextId2 = TxtOneAttemptLeft;
			  else
				display_info.TextId2 = TxtTwoAttemptsLeft;
			  break;
#ifdef SIM_PERS         
 case NEW_SIM_PLOCK_FAIL:
              pin_data->pin_case = INPUT_NEW_SIM_PLOCK;
			  display_info.TextId = TxtPsLockConfWrong;
			  display_info.TextId2 = TxtPsLockConfwrong2;
			  break;
		case SIM_LOCK_NEW_ENDISFAIL:
				{
					 int max=0;
                                   int curr= 0;
			               char buf[20];
			               pin_data->pin_case = FAILURE_PASS_CHG;
			               mfw_simlock_check_status(mmi_simlock_locktype,&max,&curr);
					 if( max != 0xff)
					 {
			               	sprintf((char*)buf,"%d tries left",(curr));
					       display_info.TextId = TxtCodeInc;
			               	display_info.TextString2 = (char*)buf;
			               	display_info.Identifier = pin_data->pin_case;
					 }
					 else
					 	display_info.TextId = TxtCodeInc;
			
			}
			//display_info.TextId=TxtPassword;
			//display_info.TextId2 = TxtPassfailed;
			  break;
	      case SIM_LOCK_STATUS:
              	pin_data->pin_case = SIM_LOCK_STATUS;
          		switch(mfw_simlock_get_lock_status(mmi_simlock_locktype))
          		{
                          case MFW_SIM_DISABLE:display_info.TextId = TxtLockDisabled;break;
                          case  MFW_SIM_ENABLE:display_info.TextId = TxtLockEnabled; break;
                          case MFW_SIM_BLOCKED:display_info.TextId = TxtBlckPerm;break;
                          case  MFW_SIM_FAILURE:display_info.TextId = TxtFailed;break;
               	}
         		 break;

		  case SIM_LOCK_SIM_REM:
                 display_info.TextId=TxtNoCard;
                 break;
		  
            case SIM_LOCK_ENDIS_FAIL:
             if(pin_data->set_state EQ DISABLE)
             {
             		
			char buf[20];
			
	              status1 = mfw_simlock_check_status(mmi_simlock_locktype,&max,&curr);
			  if(status1 != MFW_SIM_BLOCKED && status1 != MFW_SIM_PERM_BLOCKED && ( max != 0xff))
			  {
			  	pin_data->pin_case = TXT_SIM_LOCK_ALL;
				dlg_initDisplayData_TextStr(&display_info,TxtNull,TxtNull,NULL,NULL, COLOUR_STATUS_PINS);
				TRACE_EVENT(" status is not blocked");
				TRACE_EVENT_P2("The current and max value are %d and %d",curr,max);
				sprintf((char*)buf,"%d tries left",(curr));
				display_info.TextId = TxtCodeInc;
				display_info.TextString2 = (char*)buf;
				display_info.Identifier = pin_data->pin_case;
			  }
			  else
			  	display_info.TextId = TxtCodeInc;
		
              //display_info.TextId = TxtPsLockWrong;
              }
             else
             	{
			display_info.TextId = TxtCodeInc;				
             	}
		break;

	//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
	//Displays a dialog saying "Busy"
	case SIM_LOCK_BUSY:
		pin_data->pin_case = TXT_SIM_LOCK_ALL;
		display_info.TextId = TxtBusy;
		break;

		
	//x0pleela 26 July, 2006 ER: OMAPS00087586, OMAPS00087587
	//Displays a dialog saying "Busy" for wrong entry of unblocking password
	case SIM_LOCK_BUSY_UNBLOCK:
		pin_data->pin_case =PUK1_REQ ;
		display_info.TextId = TxtBusy;
		break;

	case SIM_LOCK_FCPWD_FAIL:
			  {
				char buf1[20], buf2[20] ;
				int curr_fail_reset, curr_succ_reset;
				mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
				sprintf((char*)buf1,"%d attempts left",curr_fail_reset);
				sprintf((char*)buf2,"%s", "FC Reset-Failure");								
				display_info.TextString= buf2;
				display_info.TextString2 = buf1;
				  break;
			  }
			/*	display_info.TextId = TxtCodeInc;
				break;*/
	//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
	//Displays a dialog saying "master unlock failed"
	case SIM_LOCK_MKPWD_FAIL:
			  {
				char buf1[25] ;
				sprintf((char*)buf1,"%s" , "Master Unlock Failed");
				display_info.TextString= buf1;
				display_info.TextString2 = 0;
				  break;
			  }
#endif


			case PIN1_STATUS:
			  pin_data->pin_case = PIN1_STATUS;



				TRACE_FUNCTION("set_pin_messages:check the pinrequest status");

				status.type = MFW_SIM_PIN1;//check the PIN1
				sim_pin_status(&status);

				if(status.set EQ MFW_SIM_DISABLE) /*Display the "Disabled Pin1 */
				{
					display_info.TextId = TxtDisabled;
				}
				else
				{
					display_info.TextId = TxtEnabled; /*Display the "Enabled Pin1 */
				}

		

			  display_info.TextId2 = 0;
			  display_info.TextString2 = 0;
			  break;

            /* Marcus: Issue 1609: 23/01/2003: Start */
            case PIN2_SIM_FAILURE:
                /*
                 * Failure to verify PIN2. Display
                 *  PIN2 Code
                 *  Not Available
                 * Then cancel back to the menu.
                 */
                pin_data->pin_case        = SETT_ABORT;
                display_info.TextId       = TxtPin2Code;
                display_info.TextId2      = TxtNotAvailable;
                display_info.TextString2 = 0;
                break;
            /* Marcus: Issue 1609: 23/01/2003: End */
			  
		 	}

#ifdef SIM_PERS 
    TRACE_EVENT_P1(" Status Bef: %d", status1);
    status1 = mfw_simlock_check_status(mmi_simlock_locktype,&max,&curr);
	    status2 = mfw_simlock_check_status(0,&max1,&curr1);
		TRACE_EVENT_P1("Status Aft: %d", status1);
		
  	if(((event==SIM_LOCK_NEW_ENDISFAIL)||(event == SIM_LOCK_ENDIS_FAIL)) && (curr == 0))
    {
      TRACE_EVENT("SIM_LOCK_ENDIS_FAIL,MFW_SIM_BLOCKED");
      pin_data->puk_request = TRUE;
      C_KEY_REQ=1;
		  FCUnlock_flag=1;
      set_pin_mess_destroy(mess_data->pin_mess_win);
     SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
    }
  	else if(status2 ==  MFW_SIM_PERM_BLOCKED)
    {
      TRACE_EVENT("MFW_SIM_PERM_BLOCKED");
      //pin_data->puk_request = TRUE;
      //C_KEY_REQ=1;
		  //FCUnlock_flag=1;
		  perm_blocked =1;
      set_pin_mess_destroy(mess_data->pin_mess_win);
      SEND_EVENT(pin_data->pin_win,PERM_BLK,0,0);
    }
    else
#endif  /*SIM_PERS*/
    {
	if (display_info.TextId2 == TxtOneAttemptLeft)
		dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)set_pin_info_cb, FIVE_SECS, KEY_LEFT );
	else
	  	dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)set_pin_info_cb, THREE_SECS, KEY_LEFT );

	 display_info.Identifier = pin_data->pin_case;
	set_pin_mess_destroy(mess_data->pin_mess_win);

	info_dialog(pin_data->pin_win,&display_info); //information screen
	//	Nov 03, 2005 DR: OMAPS00052032 - xpradipg  
	 dspl_Enable(1);
    }
break;
			
#ifdef SIM_PERS
	case PERM_BLK:
		TRACE_FUNCTION("Enter PERM_BLK");
		pin_data->display_id1 = TxtPhoneBlocked;
		pin_data->display_id2 = TxtDealer;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,ME_PERM_BLK,0,pin_data);
		break;


#endif 
	case PUK1_REQ:
		TRACE_FUNCTION("Enter PUK_REQ");
#ifdef SIM_PERS 
		if( C_KEY_REQ )
			pin_data->display_id1 = TxtUnblockCode;
		else
			
#endif
		pin_data->display_id1 = TxtEnterPuk1;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PUK1,0,pin_data);
		break;
	case PIN1_REQ:
		TRACE_FUNCTION(">>>TEXT ID CALLED");
		pin_data->display_id1 = TxtEnterPin1;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PIN1,0,pin_data);
		break;

#ifdef SIM_PERS        
       case TXT_SIM_LOCK_ALL:
       switch(mmi_simlock_locktype)
       {
       	case  MFW_SIM_NLOCK:
			pin_data->display_id1 = TxtEnterNLock;
       		break;
		case  MFW_SIM_SPLOCK:
			pin_data->display_id1 = TxtEnterSpLock;
			break;
		case  MFW_SIM_NSLOCK:
			pin_data->display_id1 = TxtEnterNsLock;
			break;
		case  MFW_SIM_CLOCK:
			pin_data->display_id1 = TxtEnterCLock;
			break;
		case  MFW_SIM_PLOCK:
			pin_data->display_id1 = TxtEnterPsLock;
			break;
	    //x0pleela 25 Sep, 2006 ER: OMAPS00095524			
	    //Prompting user to enter Blocked Network password
		case MFW_SIM_PBLOCK:
			pin_data->display_id1 = TxtEnterPbLock;
			break;
		}
 		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PLOCK,0,pin_data);
		break;

	case SIM_LOCK_REQ_FCPWD:
			pin_data->display_id1 = TxtPassword;
	 		set_pin_mess_destroy(mess_data->pin_mess_win);
			SEND_EVENT(pin_data->pin_win,TXT_ENTER_FCPWD,0,pin_data);
			break;
//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
	case SIM_LOCK_REQ_MKPWD:
			pin_data->display_id1 = TxtEnterMasterKey;
	 		set_pin_mess_destroy(mess_data->pin_mess_win);
			SEND_EVENT(pin_data->pin_win,TXT_ENTER_MKPWD,0,pin_data);
			break;
#endif
	case PUK2_REQ:
		pin_data->display_id1 = TxtEnterPuk2;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PUK2,0,pin_data);
		break;
	case PIN2_REQ:
		pin_data->display_id1 = TxtEnterPin2;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PIN2,0,pin_data);
		break;
	case INPUT_NEW_PIN:
#ifdef SIM_PERS
		if(C_KEY_REQ)
		{ 
		
			int sta;
			int curr_fail_reset, curr_succ_reset;
			
			
			mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);

			if( curr_succ_reset )
			{
				if( FCUnlock_flag)
				    sta=mfw_simlock_reset_fc_value((U8*)pin_data->puk,MFW_SIM_FCM) ;
			   	else
			   	    sta=mfw_simlock_reset_fc_value((U8*)pin_data->puk,MFW_SIM_FC) ;

				mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);

				TRACE_EVENT_P1("Input_new_pin: %d", sta);
				TRACE_EVENT_P1("set_pin_messages: C_KEY_REQ: %d", C_KEY_REQ);
				
				if(sta== MFW_SS_OK) 
				{
					if(FCUnlock_flag)
						FCUnlock_flag=0;

					C_KEY_REQ=0;
					TRACE_EVENT_P1("set_pin_messages: C_KEY_REQ: %d", C_KEY_REQ);
					TRACE_EVENT("set_pin_messages: SIM_LOCK_NEW_ENDSUCC_CKEY: ");
				    	pin_data->puk_request = FALSE;
					set_pin_mess_destroy(mess_data->pin_mess_win);
				    	SEND_EVENT(pin_data->pin_win,SIM_LOCK_NEW_ENDSUCC_CKEY,0,pin_data);
			    	}
			    else if(sta==MFW_SS_FAIL ) //UNBLOCK_FAILURE
			    	{
				    	TRACE_EVENT("set_pin_messages: SMLK_SHOW_FC_FAIL1: ");
			    		set_pin_mess_destroy(mess_data->pin_mess_win);


				//x0pleela 11 Sep, 2006  DR: OMASP00094215
				//Check for Ext_ERR_Busy and send the event accordingly to display a dialog "Busy"
					//for wrong entry of unblock code
					if( ( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext) AND
					    	(aciErrDesc & 0x0000FFFF) EQ EXT_ERR_Busy)
					{
						SEND_EVENT(pin_data->pin_win,SIM_LOCK_BUSY_UNBLOCK,0,pin_data);
					}
													 
			    		//x0pleela 27 Apr, 2006 DR: OMAPS00067919
			    		//To avoid executing this during bootup sequence
			    		else if( curr_fail_reset != 0)
						SEND_EVENT(pin_data->pin_win,SMLK_SHOW_FC_FAIL1,0,pin_data);

					else 
					{
						perm_blocked =1;
						SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
					}
				}
			}
		}
		else
#endif
    {
		    pin_data->display_id1 = TxtEnterNewPin;
		    set_pin_mess_destroy(mess_data->pin_mess_win);
		    SEND_EVENT(pin_data->pin_win,TXT_ENTER_NEW_PIN,0,pin_data);
			}
		break;
	case INPUT_NEW_PIN2:
		pin_data->display_id1 = TxtNewPIN2;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_NEW_PIN2,0,pin_data);
		break;
	case INPUT_NEW_PIN_AGAIN:
		pin_data->display_id1 = TxtConfPin;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_NEW_PIN_AGAIN,0,pin_data);
		break;
	case INPUT_NEW_PIN2_AGAIN:
		pin_data->display_id1 = TxtConfPin2;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_NEW_PIN_AGAIN2,0,pin_data);
		break;
	case PIN1_REQ_OLD:
		pin_data->display_id1 = TxtOldPIN;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PIN1,0,pin_data);
		break;
	case PIN2_REQ_OLD:
		pin_data->display_id1 = TxtOldPIN2;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PIN2,0,pin_data);
		break;
	case FDN_ACTIVATED:
		pin_data->display_id1 = TxtPleaseWait;//TxtActivated;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,FDN_WAIT,0,pin_data);
		break;
	case ADN_ACTIVATED:
		pin_data->display_id1 = TxtPleaseWait;//TxtDeActivated;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,FDN_WAIT,0,pin_data);
		break;
#ifdef SIM_PERS
		 case SIM_LOCK_REQ_OLD:
              pin_data->display_id1 = TxtEnterOldPsLock;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PLOCK,0,pin_data);
		break;
               case SIM_LOCK_REQ_NEW:
                pin_data->display_id1 = TxtEnterPsLockNew;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_NEW_SIMLOCK,0,pin_data);
		break;
		  case INPUT_NEW_SIM_PLOCK_AGAIN:
              pin_data->display_id1 = TxtEnterPsLockconf;
		set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_NEW_SIMLOCK_AGAIN,0,pin_data);
              break;
#endif
	default:
		break;
  }
		
}


/*******************************************************************************

 $Function:	set_pin_info_cb
 $Description:	settings pin information screen call back
 $Returns:		void
 $Arguments:	win, identifier, reason
*******************************************************************************/
void set_pin_info_cb(T_MFW_HND win, USHORT identifier, UBYTE reasons)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user;

	TRACE_FUNCTION("MmiPins: set_pin_info_cb");

	switch(identifier)
	{

		case PIN_OK:
			SEND_EVENT(pin_data->pin_win,PIN_OK_END,0,NULL);//PIN was needed
			break;
		case PIN1_STATUS:
			SEND_EVENT(pin_data->pin_win,PIN1_STATUS_END,0,NULL);
			break;
		case UNBL_OK:
		case PIN1_REQ:
		case PIN2_REQ:
		case PUK1_REQ:
		case PUK2_REQ:
		case INPUT_NEW_PIN:
		case INPUT_NEW_PIN2:
		case PIN1_CH_END:
		case PIN2_CH_END:
		case FDN_UNBL_OK:
		case PIN1_REQ_OLD:
		case PIN2_REQ_OLD:
		case IDLE_GSM_FAIL:
		case SETT_ABORT:        // Marcus: Issue 1609: 23/01/2003
			SEND_EVENT(pin_data->pin_win,identifier,0,NULL);//pin_main data !!
			break;
		default:		
		switch (reasons)
		{
			case INFO_KCD_LEFT:
			case INFO_KCD_RIGHT:
		
			case INFO_TIMEOUT:
#ifdef SIM_PERS
			{
			        pin_skClear();
				setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
			}
		
#else
			dspl_ClearAll();
#endif /* SIM_PERS*/
			break;
		}
			break;
	}

}

/*******************************************************************************

 $Function:	gsm_set_test 
 $Description:	test if gsm string
 $Returns:		status int
 $Arguments:	win, pin editor attributes 
*******************************************************************************/
static int gsm_set_test(T_MFW_HND win,void * edt_pin)
{
	int status;
	T_pin_edt * edt_data = (T_pin_edt *)edt_pin;


//	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;    /* Warning Correction */
	T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
	T_pin * pin_data = (T_pin *)win_pin->user; // pin main data

	TRACE_FUNCTION("MmiPins:gsm_set_test");

	status = ss_check_ss_string((UBYTE*)edt_data->pin);/* check GSM-String */
	switch(status)
	{
		case MFW_SS_SIM_REG_PW:
				if(!(edt_data->gsm_state))
				{
					switch(pin_data->set_state)
					{
						case CHANGE_PIN:/* replace * with string id */
							if(!(strncmp((char*)edt_data->pin,"**04*",IDENT_GSM_1)))
							{
								edt_data->gsm_state = TRUE;
								strncpy((char*)edt_data->edtbuf,(char*)edt_data->pin,edt_data->editor_index-1);
								/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
								ATB_edit_Refresh(edt_data->editor);  /* String has changed, refresh editor */
								ATB_edit_Show(edt_data->editor);	/* Show the editor */
#else /* NEW_EDITOR */
								edtShow(edt_data->editor_handle);
#endif /* NEW_EDITOR */

							}
							else
							{
								edt_data->gsm_state = FALSE;
								dspl_ClearAll();
								clear_edit_array (edt_data);
							    set_pin_edt_destroy(edt_data->pin_edt_win);
								if(pin_data->puk_request)
								{
									pin_data->pin_case = PUK1_REQ;
								}
								else
								{
									if((pin_data->set_state EQ ENABLE) || (pin_data->set_state EQ DISABLE))
										pin_data->pin_case = PIN1_REQ;
									else
										pin_data->pin_case = PIN1_REQ_OLD;/* pin1/2 change */
								}
								SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
							}
							break;
						case CHANGE_PIN2:/* replace * with string id */
							if(!(strncmp((char*)edt_data->pin,"**042*",IDENT_GSM_2)))
							{
								edt_data->gsm_state = TRUE;
								strncpy((char*)edt_data->edtbuf,(char*)edt_data->pin,edt_data->editor_index-1);
								/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
								ATB_edit_Refresh(edt_data->editor);  /* String has changed, refresh editor */
								ATB_edit_Show(edt_data->editor);	/* Show the editor */
#else /* NEW_EDITOR */
								edtShow(edt_data->editor_handle);
#endif /* NEW_EDITOR */
							}
							else
							{
								edt_data->gsm_state = FALSE;
								dspl_ClearAll();
								clear_edit_array (edt_data);
							    set_pin_edt_destroy(edt_data->pin_edt_win);
								if(pin_data->puk_request)
								{
									pin_data->pin_case = PUK2_REQ;
								}
								else
								{
									pin_data->pin_case = PIN2_REQ_OLD;
								}
								SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
							}
							break;
						default:
							edt_data->gsm_state = FALSE;
							dspl_ClearAll();
							clear_edit_array (edt_data);
							set_pin_edt_destroy(edt_data->pin_edt_win);
							if(pin_data->puk_request)
							{
								if(pin_data->set_state EQ CHANGE_PIN2)
									pin_data->pin_case = PUK2_REQ;
								else
									pin_data->pin_case = PUK1_REQ;
							}
							else
							{
								if(pin_data->set_state EQ CHANGE_PIN)
									pin_data->pin_case = PIN1_REQ_OLD;
								else if(pin_data->set_state EQ CHANGE_PIN2)
									pin_data->pin_case = PIN2_REQ_OLD;
								else
									pin_data->pin_case = PIN1_REQ;/* PIN enable/disable */
							}
							SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
							break;
					}
				}
			return status;

		case MFW_SS_SIM_UNBLCK_PIN:
				if(!(edt_data->gsm_state))
				{
					switch(edt_data->pin_case_edit)
					{
						case INPUT_PUK1:/* replace * with string id */
							if(!(strncmp((char*)edt_data->pin,"**05*",IDENT_GSM_1)))
							{
								edt_data->gsm_state = TRUE;
								strncpy((char*)edt_data->edtbuf,(char*)edt_data->pin,edt_data->editor_index-1);
								/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
								ATB_edit_Refresh(edt_data->editor);  /* String has changed, refresh editor */
								ATB_edit_Show(edt_data->editor);	/* Show the editor */
#else /* NEW_EDITOR */
								edtShow(edt_data->editor_handle);
#endif /* NEW_EDITOR */
							}
							else
							{
								edt_data->gsm_state = FALSE;
								dspl_ClearAll();
								clear_edit_array (edt_data);
							    set_pin_edt_destroy(edt_data->pin_edt_win);
								pin_data->pin_case = PUK1_REQ;
								SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
							}
							break;
						case INPUT_PUK2:/* replace * with string id */
							if(!(strncmp((char*)edt_data->pin,"**052*",IDENT_GSM_2)))
							{
								edt_data->gsm_state = TRUE;
								strncpy((char*)edt_data->edtbuf,(char*)edt_data->pin,edt_data->editor_index-1);
								/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
								ATB_edit_Refresh(edt_data->editor);  /* String has changed, refresh editor */
								ATB_edit_Show(edt_data->editor);	/* Show the editor */
#else /* NEW_EDITOR */
								edtShow(edt_data->editor_handle);
#endif /* NEW_EDITOR */
							}
							else
							{
								edt_data->gsm_state = FALSE;
								dspl_ClearAll();
								clear_edit_array (edt_data);
							    set_pin_edt_destroy(edt_data->pin_edt_win);
								pin_data->pin_case = PUK2_REQ;
								SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
							}
							break;
						default:
							edt_data->gsm_state = FALSE;
							dspl_ClearAll();
							clear_edit_array (edt_data);
							set_pin_edt_destroy(edt_data->pin_edt_win);
							if(pin_data->puk_request)
							{
								if(pin_data->set_state EQ CHANGE_PIN2)
									pin_data->pin_case = PUK2_REQ;
								else
									pin_data->pin_case = PUK1_REQ;/* pin1 change,disable,enable */
							}
							else
							{
								if(pin_data->set_state EQ CHANGE_PIN)
									pin_data->pin_case = PIN1_REQ_OLD;
								else if(pin_data->set_state EQ CHANGE_PIN2)
									pin_data->pin_case = PIN2_REQ_OLD;
								else
									pin_data->pin_case = PIN1_REQ; /* pin enable/disable */
							}
							SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
							break;
					}
				}
			return status;
		case MFW_SS_DIAL:	       /* string not yet detected  */
        case MFW_SS_USSD:  /*JVJ SPR 1040- The short USSD strings should also be 
                              considered in this case, since they can be confused with dialled numbers  
                             */
				edt_data->gsm_state = FALSE;
			return status;
		default:
			edt_data->gsm_state = FALSE;
			dspl_ClearAll();
			clear_edit_array (edt_data);
			set_pin_edt_destroy(edt_data->pin_edt_win);
			SEND_EVENT(pin_data->pin_win,GSM_FAIL,0,NULL);/*entering screeen not allowed */
			return status;
	}
}


/*******************************************************************************

 $Function:	set_mode_fdn_adn
 $Description:	activate/deactivate FDN/ADN
 $Returns:		none
 $Arguments:	win, pin editor attributes
*******************************************************************************/
static void set_mode_fdn_adn(T_MFW_HND win, void * string)
{
	T_pin * pin_data = (T_pin *)string;

    TRACE_FUNCTION("MmiPins:set_mode_fdn_adn");

	if((pin_data->set_state EQ FDN_ACTIV) || (pin_data->set_state EQ PIN2_CHECK))
	{
		if(phb_set_mode(PHB_FDN,pin_data->old_pin) EQ MFW_PHB_OK)
		{
			SEND_EVENT(pin_data->pin_win,FDN_ACTIVATED,0,pin_data);/* activate FDN successfull */
		}
		else
		{
			SEND_EVENT(pin_data->pin_win,FDN_FAIL,0,pin_data);/* activate FDN unsuccessfull */
		}
	}
	else
	{
		if(phb_set_mode(PHB_ADN,pin_data->old_pin) EQ MFW_PHB_OK)
		{
			SEND_EVENT(pin_data->pin_win,ADN_ACTIVATED,0,pin_data);/* deactivate FDN  successfull */
		}
		else
		{
			SEND_EVENT(pin_data->pin_win,FDN_FAIL,0,pin_data);/* deactivate FDN unsuccessfull */
		}
	}
}


/*******************************************************************************

 $Function:	backpinFDNactdeact
 $Description:	when callback event is received from phonebook
		(MmiPhbk:phbkEvent)
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
void backpinFDNactdeact(void)
{

	T_MFW_WIN * win_data = ((T_MFW_HDR *)set_pin_windows)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	TRACE_FUNCTION("MmiPins.backpinFDNactdeact");

	if(pin_data->set_state EQ FDN_ACTIV)
	{
		SEND_EVENT(pin_data->pin_win,FDN_ACT_END,0,pin_data);
	}
	else if(pin_data->set_state EQ FDN_DEACTIV)
	{
		SEND_EVENT(pin_data->pin_win,FDN_DEACT_END,0,pin_data);
	}
}



/*******************************************************************************

 $Function:	pin2_check 
 $Description:	PIN2 check :call from menu Services and Phonebook
 $Returns:		status int
 $Arguments:	parent window
*******************************************************************************/
int pin2_check (T_MFW_HND parent_window)
{
		T_MFW_HND win = setting_pin_create(parent_window);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;
		T_MFW_SIM_PIN_STATUS status;

		if(win != NULL) /* x0039928 - Lint warning removal */
		{
		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;
	
//		T_DISPLAY_DATA display_info;
		
	
		pin_data->set_state = PIN2_CHECK;

	TRACE_FUNCTION("MmiPins:pin2_check");

	status.type = MFW_SIM_PIN2;
		sim_pin_status(&status);
	       // June 16, 2005  REF: CRR 31267  x0021334
	       // Check if PIN2 and PUK2 are initialised
		if((sim_pin_count(MFW_SIM_PIN2) > 0) AND (sim_pin_count(MFW_SIM_PUK2) NEQ 0))
		{
			SEND_EVENT(pin_data->pin_win,PIN2_REQ,0,pin_data);
		}
		// If PIN2 is not initialised, ask for PUK 2
		else if ((sim_pin_count(MFW_SIM_PIN2) EQ 0) AND (sim_pin_count(MFW_SIM_PUK2) > 0))
		{
			pin_data->puk_request = TRUE;
			SEND_EVENT(pin_data->pin_win,PUK2_REQ,0,pin_data);
		}
		// Else display that PIN2 is not available
		else
		{
			SEND_EVENT(pin_data->pin_win,PIN2_SIM_FAILURE,0,pin_data);
		}
		}
		return 1;
}



	
/*******************************************************************************

 $Function:	pin1_check 
 $Description:	PIN1 check :call from menu Services (AOC)
 $Returns:		status int
 $Arguments:	parent window
*******************************************************************************/
int pin1_check (T_MFW_HND parent_window)
{
		T_MFW_HND win = setting_pin_create(parent_window);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;

		if(win != NULL) /* x0039928 - Lint warning removal */
		{
		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;
//		T_MFW_SIM_PIN_STATUS status;  /* Warning Correction */

		pin_data->set_state = PIN1_CHECK;

	TRACE_FUNCTION("MmiPins:pin1_check");
		if(sim_pin_count(MFW_SIM_PIN1) > 0)
		{
			SEND_EVENT(pin_data->pin_win,PIN1_REQ,0,pin_data);
		}
		else
		{   /* not included the state of the puk counter ! */
			pin_data->puk_request = TRUE;
			SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
		}
		}
		return 1;
}

/*******************************************************************************

 $Function:	fdnActivate
 $Description:	activate FDN
 $Returns:		status int
 $Arguments:	menu, item
*******************************************************************************/
int fdnActivate(struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
	TRACE_FUNCTION("MmiPins:fdnActivate");
	pin2_fdn_activate();/*	check if PIN2 */
    return 1;
}



/*******************************************************************************

 $Function:	fdnDeactivate 
 $Description:	deactivate FDN
 $Returns:		status int
 $Arguments:	menu, item
*******************************************************************************/
int fdnDeactivate(struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{

	TRACE_FUNCTION("MmiPins:fdnDeactivate");
    pin2_fdn_deactivate(); //	check if PIN2
    return 1;
}


/*******************************************************************************

 $Function:	set_fdn_on_item_flag 
 $Description:	decision about menu entry FDN "on"
 $Returns:		0 if show entry, 1 if not
 $Arguments:	menu, menu attributes, item
*******************************************************************************/
U16 set_fdn_on_item_flag (struct MfwMnuTag * m, struct MfwMnuAttrTag * ma, struct MfwMnuItemTag * mi)
{

    TRACE_FUNCTION("MmiPins:set_fdn_on_item_flag");

	if(phb_get_mode()EQ PHB_RESTRICTED) /*if FDN on */
		return MNU_ITEM_HIDE;		/* show no entry "on" */
	else
		return 0;		       /* show entry "on"  */
}


/*******************************************************************************

 $Function:	set_fdn_off_item_flag
 $Description:	decision about menu entry FDN "off"
 $Returns:		0 if show entry off, 1 if not
 $Arguments:	menu, menu attributes, item
*******************************************************************************/
U16 set_fdn_off_item_flag (struct MfwMnuTag * m, struct MfwMnuAttrTag * ma, struct MfwMnuItemTag * mi)
{
   TRACE_FUNCTION("MmiPins:set_fdn_off_item_flag");

   if(phb_get_mode() NEQ PHB_RESTRICTED) /* if FDN off */
		return MNU_ITEM_HIDE;		 /* show no entry "off" */
	else
		return 0;			 /* show entry "off"  */
}



/*******************************************************************************

 $Function:	gsm_idle 
 $Description:	handle gsm string in idle screen (unblock and change pin)
 $Returns:		Status int
 $Arguments:	parent window, string
*******************************************************************************/
int gsm_idle (T_MFW_HND parent_window,char * string)
{
		T_MFW_HND win = setting_pin_create(parent_window);
		T_MFW_WIN * win_data = NULL;
		T_pin * pin_data = NULL;

		if(win != NULL) /* x0039928 - Lint warning removal */
		{
		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;

		pin_data->set_state = IDLE_GSM;
		pin_data->gsm_state = TRUE;

	TRACE_FUNCTION("MmiPins:gsm_idle");

		gsm_sec_execute_set(win,string);
		}
		return 1;
}


/*******************************************************************************

 $Function:	gsm_sec_execute_set
 $Description:	GSM-String will be executed in settings and idle
 $Returns:		none
 $Arguments:	win, pin attributes
*******************************************************************************/
static void gsm_sec_execute_set(T_MFW_HND win,void *string)
{
	    T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
		T_pin * pin_data = (T_pin *)win_data->user;
		int result;

	TRACE_FUNCTION("MmiPins:gsm_sec_execute_set");

		if(pin_data->set_state NEQ IDLE_GSM)
		{
			T_pin_edt * edt_data = (T_pin_edt *)string;

			result = ss_execute_transaction((UBYTE*)edt_data->pin,0);/* ussd_man = 0 while SSD */
			dspl_ClearAll();
			clear_edit_array (edt_data);
			pin_edt_destroy(edt_data->pin_edt_win);
			//xrashmic 1 Jul, 2006 OMAPS00075784
			//After the PUK is verified, security menu has to be displayed. 
			//Hence we need to delete the pin window or else the blue  
			//screen is displayed
			//xrashmic 6 Jul, 2006 OMAPS00080708
			//The pin window is necessary for displaying the error message for MFW_SS_FAIL
			if(result!=MFW_SS_FAIL)
			pin_destroy(pin_data->pin_win);		
		}
		else
			result = ss_execute_transaction((UBYTE*)string,0);/* ussd_man = 0 while SSD */

		switch(result)
		{
			case MFW_SS_SIM_REG_PW:     /* change PIN1/2		*/
				TRACE_FUNCTION("MmiPins:gsm_idle:MFW_SS_SIM_REG_PW");
				break;
			case MFW_SS_SIM_UNBLCK_PIN: /* unblock PIN1/2		*/
				TRACE_FUNCTION("MmiPins:gsm_idle:MFW_SS_SIM_UNBLCK_PIN");
				break;
			case MFW_SS_FAIL:
				TRACE_FUNCTION("MmiPins:gsm_idle:MFW_SS_FAIL");
				sett_pin_mess(win,GSM_FAIL);/* new PIN and new PIN again are not the same */
				break;
			default:
				break;
		}
}


/*******************************************************************************

 $Function:	pins_editor_cb

 $Description:	

 $Returns:		

 $Arguments:	
 
*******************************************************************************/

static void pins_editor_cb (T_MFW_HND win, USHORT Identifier, SHORT reason)
{
	T_MFW_WIN   * win_data = ((T_MFW_HDR *) win)->data;
	T_pin	      * data	 = (T_pin *)win_data->user;

	T_pin * pin_data = (T_pin *)win_data->user;//pin main data
	//T_DISPLAY_DATA display_info;
//x0pleela 21 Apr, 2006  DR: OMAPS00067919
#ifdef SIM_PERS
	int ret; //used to check the retun type of function mfw_simlock_check_lock_bootup()
#endif
	TRACE_FUNCTION ("pins_editor_cb()");

	/* SPR#1746 - SH - In the case INSERT_CARD or CARD_REJECTED,
	 * the editor has not been destroyed at this point.
	 * BUT in all other cases it has, so we need to set the
	 * editor handle to NULL. */
	 
// Nov 24, 2005, a0876501, DR: OMAPS00045909
	if (Identifier!=INSERT_CARD && Identifier!=CARD_REJECTED 
		&& Identifier!=SHOW_IMEI_INVALID		
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS			
		//x0pleela 30 Aug, 2006 DR: OMAPS00091250
		&& Identifier != NO_MEPD_DATA
#endif
		)
	{
		pin_editor_window = NULL;
	}

	switch (reason)
	{

		case INFO_EMERGENCY:		
			TRACE_EVENT_P1(" call %s", data->edtbuf);	

			/* SPR#1746 - SH - Function modified to provide context */
			show_confirmation (win, Identifier);

			break;
			
		case INFO_KCD_LEFT:
			switch (Identifier)
			{

				case PIN1_REQ:
				{	TRACE_EVENT ("PIN1_REQ");			

		    // verification pin1
					sim_verify_pin(MFW_SIM_PIN1, data->edtbuf);  
				}
					break;
#ifdef SIM_PERS
					case PERM_BLK:
						break;
#endif
				case PUK1_REQ:					
				{
#ifdef SIM_PERS
					int status,curr_fail_reset, curr_succ_reset;
					
					TRACE_FUNCTION ("PUK1-REQ");
					strncpy((char*)pin_data->puk, data->edtbuf,MAX_PIN);  
					status = mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
//	Nov 03, 2005 DR: OMAPS00050595 - xpradipg
//	the check for C_KEY_REQ is made first to find if the PUK request was for 
//	SIM Personalization or for the SIM PIN1
					
			if(C_KEY_REQ)
			{
				if((curr_fail_reset!=0) && (curr_succ_reset!=0) )
				{
						if( FCUnlock_flag)
						{
							TRACE_FUNCTION("FCUnlock_flag: TRUE");
							status= mfw_simlock_reset_fc_value((U8*)pin_data->puk,MFW_SIM_FCM);
						}
						else
						{
							TRACE_FUNCTION("FCUnlock_flag: FALSE");
                            
						       // June 07, 2006    DR: OMAPS00080701   x0021334
                                                 // Descripton: Phone hangs while unblocking SIMP during bootup.
                                                 // Assign 'SIMP_BOOTUP' to 'sim_unlock_in_prog' to indicate that
                                                 // the operation is happeneing during boot-up sequence. 
						       sim_unlock_in_prog = SIMP_BOOTUP;
							status= mfw_simlock_reset_fc_value((U8*)pin_data->puk,MFW_SIM_FC);
						}

						mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);
						if( status != MFW_SS_OK)
						{
							TRACE_FUNCTION("UNBLOCK_FAILURE");
							mmi_simlock_aciErrDesc = aciErrDesc;

							if((aciErrDesc & 0x0000FFFF) EQ CME_ERR_SimNotIns)
						     	 SEND_EVENT(pin_data->pin_win,SIM_LOCK_SIM_REM,0,pin_data);
	
							//x0pleela 11 Sep, 2006  DR: OMASP00094215
							//Handling CME error busy while unlocking a locked category
							else if( ( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext) AND
									(aciErrDesc & 0x0000FFFF) EQ EXT_ERR_Busy)
							  SEND_EVENT(pin_data->pin_win,SIM_LOCK_BUSY_UNBLOCK,0,pin_data);

							else
							{
								//x0pleela 27 Apr, 2006 DR: OMAPS00067919
						    		//To avoid executing this during bootup sequence
						    		if(FCUnlock_flag) //x0pleela 27 Apr, 2006 DR: OMAPS00067919
						    		{
									if( curr_fail_reset )
										SEND_EVENT(pin_data->pin_win, SMLK_SHOW_FC_FAIL, 0, pin_data);
									else
									{
										perm_blocked=1;
										SEND_EVENT(pin_data->pin_win, PERM_BLK, 0, pin_data);
									}
								}
							}
						}
					 	else 
						{
							TRACE_FUNCTION("UNBLOCK_SUCESS");
							if(FCUnlock_flag)
								FCUnlock_flag=0;
							//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
							//Update mmi_simlock_aciErrDesc with the latest CME error
							mmi_simlock_aciErrDesc = aciErrDesc;

							if( curr_succ_reset )
								SEND_EVENT(pin_data->pin_win, SMLK_SHOW_FC_SUCC, 0, pin_data);
							else
							{
								perm_blocked=1;
								SEND_EVENT(pin_data->pin_win, PERM_BLK, 0, pin_data);
							}
						}
					}
					else
					{
						perm_blocked = 1;
						SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
					}

				}
			else
			{
#endif			
				strncpy((char*)pin_data->puk, data->edtbuf,MAX_PIN);  
				SEND_EVENT(pin_data->pin_win,INPUT_NEW_PIN,0,pin_data);
#ifdef SIM_PERS
			}
#endif				
		}
					break;

#ifdef SIM_PERS
				//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
				//Performs master unlock and sends corresponding events during bootup
				case INPUT_MASTER_KEY_REQ:
				{
					int status;
					strncpy((char*)pin_data->mk_pin, data->edtbuf,MAX_PIN);  
					status = mfw_simlock_master_unlock((U8*)pin_data->mk_pin, MFW_SIM_MKEY);
					if( status EQ MFW_SS_OK )
						SEND_EVENT(pin_data->pin_win, SMLK_SHOW_MK_SUCC, 0, pin_data);

					//x0pleela 13 Nov, 2006 DR: OMAPS00103356
					//send wrong password event 
					else if ( status EQ MFW_WRONG_PWD) 
						SEND_EVENT(pin_data->pin_win, SMLK_SHOW_WRONG_PWD, 0, pin_data);
					//x0pleela 13 Nov, 2006 DR: OMAPS00103356
					//send event which says all the dependent categories are unlocked
					else if ( status EQ MFW_MASTER_OK) 
						SEND_EVENT(pin_data->pin_win, SMLK_SHOW_DEP_CATS_UNLOCKED, 0, pin_data);
					else
						SEND_EVENT(pin_data->pin_win, SMLK_SHOW_MK_FAIL, 0, pin_data);
					
				}
				break;

				case INPUT_SIM_PIN_REQ:
				case INPUT_NLOCK_PIN_REQ:
				case INPUT_NSLOCK_PIN_REQ:
				case INPUT_SPLOCK_PIN_REQ:
				case INPUT_CLOCK_PIN_REQ: 
				//x0pleela 25 Sep, 2006 ER: OMAPS00095524
				case INPUT_PBLOCK_PIN_REQ:
				{
					S16 lcktype = 0;
				int curr_fail_reset1, curr_succ_reset1;

				mfw_simlock_check_status(0, &curr_fail_reset1, &curr_succ_reset1);

					if ((!curr_fail_reset1)||(!curr_succ_reset1))
					{
						perm_blocked =1;
						SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
					}	
					else
					{
					
						strncpy((char*)pin_data->puk, data->edtbuf,MAX_PIN);  
						//for CPIN to CLCK change
						switch(Identifier)
						{
							case INPUT_SIM_PIN_REQ:
								lcktype=MFW_SIM_PLOCK;
								break;
							case INPUT_NLOCK_PIN_REQ:
								lcktype=MFW_SIM_NLOCK;
								break;
							case INPUT_NSLOCK_PIN_REQ:
								lcktype=MFW_SIM_NSLOCK;
								break;
							case INPUT_SPLOCK_PIN_REQ:
								lcktype=MFW_SIM_SPLOCK;
								break;
							case INPUT_CLOCK_PIN_REQ: 
								lcktype=MFW_SIM_CLOCK;
								break;

							//x0pleela 25 Sep, 2006 ER: OMAPS00095524
							case INPUT_PBLOCK_PIN_REQ:
								lcktype=MFW_SIM_PBLOCK;
								break;								
						}
						ret = mfw_simlock_check_lock_bootup((char*)pin_data->puk, lcktype);
						//x0pleela 20 july, 2006 ER: OMAPS00087586, OMAPS00087587
						//delete the simp list window handler
						win_delete(pin_data->simp_list_win);
						if( ret == BOOTUP_LOCK_SUCCESS)
						{
							TRACE_FUNCTION("BOOTUP_LOCK_SUCCESS");
							simp_cpin_flag = FALSE;
							SEND_EVENT(pin_data->pin_win,SIM_LOCK_PERS_CHK_OK,0,pin_data);
						}
						else if (ret ==BOOTUP_OK) 
						{
						  sim_simlock_cpin_code (simp_cpin_code);
						}
						else
						{
							TRACE_FUNCTION("BOOTUP_LOCK_FAILURE");
							TRACE_EVENT_P1("aciErrDesc %d ",aciErrDesc);
							if( simp_cpin_flag )
							 sim_simlock_cpin_code (simp_cpin_code);
							else
							{
								//x0pleela 20 July, 2006 ER: OMAPS00087586, OMAPS00087587
								//get the busy state
								if( mfw_simlock_get_busy_state() )
								{
									//send event to display a dialog Busy for the user
									SEND_EVENT(pin_data->pin_win,SIM_LOCK_BUSY_BOOTUP,0,pin_data);
								}
								    //x0pleela 25 Sep, 2006 ER: OMAPS00095524	
								    //check for CME class and handle all CME errors
								else if( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Cme)
								{
									switch(aciErrDesc & 0x0000FFFF)
									{
										case CME_ERR_NetworkPersPinReq:
											TRACE_EVENT("CME_ERR_NetworkPersPinReq");
											//x0pleela 20 July, 2006
											//check for Master Unlock option enabled. 
											//If so, then display the menu with options Network unlock and Master Unlock	
											if( simlock_get_masterkey_status())
											{
												mmi_simlock_locktype = MFW_SIM_NLOCK;
												pin_data->simp_list_win = mmi_simlock_category_menus(win);
											}
											else
												SEND_EVENT(pin_data->pin_win,INPUT_NLOCK_PIN_REQ,0,pin_data);
										break;
											
										case CME_ERR_NetworkSubsetPersPinReq:
											TRACE_EVENT("CME_ERR_NetworkSubsetPersPinReq");
											//x0pleela 20 July, 2006
											//check for Master Unlock option enabled. 
											//If so, then display the menu with options Network subset unlock and Master Unlock	
											if( simlock_get_masterkey_status())
											{
												mmi_simlock_locktype = MFW_SIM_NSLOCK;
												pin_data->simp_list_win = mmi_simlock_category_menus(win);
											}
											else
												SEND_EVENT(pin_data->pin_win,INPUT_NSLOCK_PIN_REQ,0,pin_data);
										break;
											
										case CME_ERR_ProviderPersPinReq:
											TRACE_EVENT("CME_ERR_ProviderPersPinReq");
											//x0pleela 20 July, 2006
											//check for Master Unlock option enabled. 
											//If so, then display the menu with options service provider unlock and Master Unlock	
											if( simlock_get_masterkey_status())
											{
												mmi_simlock_locktype = MFW_SIM_SPLOCK;
												pin_data->simp_list_win = mmi_simlock_category_menus(win);
											}
											else
												SEND_EVENT(pin_data->pin_win,INPUT_SPLOCK_PIN_REQ,0,pin_data);
										break;
											
										case CME_ERR_CorporatePersPinReq:
											TRACE_EVENT("CME_ERR_CorporatePersPinReq");
											//x0pleela 20 July, 2006
											//check for Master Unlock option enabled. 
											//If so, then display the menu with options Corporate unlock and Master Unlock	
											if( simlock_get_masterkey_status())
											{
												mmi_simlock_locktype = MFW_SIM_CLOCK;
												pin_data->simp_list_win = mmi_simlock_category_menus(win);
											}
											else
												SEND_EVENT(pin_data->pin_win,INPUT_CLOCK_PIN_REQ,0,pin_data);
										break;
											
										case CME_ERR_PhSimPinReq:
											TRACE_EVENT("CME_ERR_PhSimPinReq");
											//x0pleela 20 July, 2006
											//check for Master Unlock option enabled. 
											//If so, then display the menu with options SIM unlock and Master Unlock	
											if( simlock_get_masterkey_status())
											{
												mmi_simlock_locktype = MFW_SIM_PLOCK;
												pin_data->simp_list_win = mmi_simlock_category_menus(win);
											}
											else
												SEND_EVENT(pin_data->pin_win,INPUT_SIM_PIN_REQ,0,pin_data);
										break;

										case CME_ERR_PhoneFail:
										case CME_ERR_NetworkPersPukReq:
										case CME_ERR_NetworkSubsetPersPukReq:
										case CME_ERR_ProviderPersPukReq:
										case CME_ERR_CorporatePersPukReq:
										{
											int status, curr_fail_reset, curr_succ_reset;
											TRACE_EVENT("PUK Req");
											status = mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);

											if( status==MFW_SIM_BLOCKED)
											{
												C_KEY_REQ = 1;
												//x0pleela 20 July, 2006
												//check for Master Unlock option enabled. 
												//If so, then display the menu with options Unblock ME and Master Unlock	
											if( simlock_get_masterkey_status())
											{
											  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
											  }
									  		else
												SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
											}
											else if (status == MFW_SIM_PERM_BLOCKED)
											{
												perm_blocked =1;
												SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
											}	
										}
										break;	


										case CME_ERR_WrongPasswd:
										default:
											TRACE_EVENT("CME_ERR_WrongPasswd");
											SEND_EVENT(pin_data->pin_win,Identifier,0,pin_data);
											break;
									}
							}
							    //x0pleela 25 Sep, 2006 ER: OMAPS00095524	
							    //check for Ext class and handle all Extension errors
							else if( ((aciErrDesc & 0xFFFF0000) >> 16) EQ ACI_ERR_CLASS_Ext)
							{
								switch(aciErrDesc & 0x0000FFFF)
								{
									//Request for Blocked Network Password
									case EXT_ERR_BlockedNetworkPersPinReq:
										TRACE_EVENT("EXT_ERR_BlockedNetworkPersPinReq");
										  if( simlock_get_masterkey_status())
										  {
										  	mmi_simlock_locktype = MFW_SIM_PBLOCK;
										  	pin_data->simp_list_win = mmi_simlock_category_menus(win);
										  }
										  else
											SEND_EVENT(pin_data->pin_win,INPUT_PBLOCK_PIN_REQ,0,pin_data);
									break;

									//Request for Blocked Network Unblock code 
									case EXT_ERR_BlockedNetworkPersPukReq:
									{
										int status,curr_fail_reset, curr_succ_reset;
										TRACE_EVENT("PUK Req");
										status = mfw_simlock_check_status(0, &curr_fail_reset, &curr_succ_reset);

										if( status==MFW_SIM_BLOCKED)
										{
											C_KEY_REQ = 1;
											//check for Master Unlock option enabled. 
											//If so, then display the menu with options Unblock ME and Master Unlock	
											if( simlock_get_masterkey_status())
											{
												pin_data->simp_list_win = mmi_simlock_category_menus(win);
											}
											else
												SEND_EVENT(pin_data->pin_win,PUK1_REQ,0,pin_data);
										}
										else if (status == MFW_SIM_PERM_BLOCKED)
										{
											perm_blocked =1;
											SEND_EVENT(pin_data->pin_win,PERM_BLK,0,pin_data);
										}	
									}
									break;	

									default:
										break;
								}
							}
					   	}	
					}
				}
			}
				break;
#endif
					
				case INPUT_NEW_PIN:	
				{	TRACE_EVENT ("INPUT_NEW_PIN");	
					strncpy((char*)pin_data->new_pin, data->edtbuf,MAX_PIN);  
					SEND_EVENT(pin_data->pin_win,INPUT_NEW_PIN_AGAIN,0,pin_data);
				}
					break;

				case INPUT_NEW_PIN_AGAIN:
				{	//if new pins match
					if(strcmp((char*)pin_data->new_pin, (char*)data->edtbuf) EQ 0)
						sim_unblock_pin(MFW_SIM_PUK1, (char*)pin_data->puk, (char*)pin_data->new_pin);/* unblock pin1 */
					else	//otherwise ask for new pin again
						SEND_EVENT(pin_data->pin_win,NEW_PIN_FAIL,0,NULL);
				}
					break;
				default:
					break;
			}
			break;
					
	    case INFO_KCD_RIGHT:
	    case INFO_KCD_CLEAR:

			TRACE_EVENT ("INFO_KCD_RIGHT pressed");

			switch (Identifier)
			{

				default:
					break;
			}
    default:
			break;
	}
}


/*******************************************************************************

 $Function:	call emergency confirmation

 $Description:	 
 
 $Returns:		

 $Arguments:	
				
*******************************************************************************/

/* SPR#1746 - SH - Add 'Identifier' so previous context is known */

void show_confirmation (T_MFW_HND win, USHORT Identifier)
{
    T_DISPLAY_DATA   display_info;
	dlg_initDisplayData_TextId( &display_info, TxtSoftOK, TxtSoftBack, TxtSoftCall, TxtEmergency , COLOUR_STATUS_PINS);
	dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)show_confirmation_cb, FOREVER, KEY_HUP | KEY_LEFT| KEY_RIGHT );

	/* SPR#1746 - SH - Store Identifier in display info, so it can be accessed by callback */
	display_info.Identifier = Identifier;
      /*
       * Call Info Screen
       */

    info_dialog (win, &display_info);

}


int mmiPinsEmergencyCall(void)
{
	return((int)pin_emergency_call);
}

void mmiPinsResetEmergencyCall(void)
{
	pin_emergency_call = FALSE;
	return;
}

/*******************************************************************************

 $Function:	idle_imei_info_cb

 $Description:	 
 
 $Returns:		

 $Arguments:	
				
*******************************************************************************/



static int show_confirmation_cb(T_MFW_HND win, USHORT identifier, UBYTE reason)
{

	T_MFW_WIN   * win_data = ((T_MFW_HDR *) win)->data;
	T_pin	      * data	 = (T_pin *)win_data->user;

    switch (reason)	 
   {

	case INFO_KCD_LEFT:
			if (mmiStart_animationComplete() != TRUE)
				pin_emergency_call = TRUE;

			// call emergency number
			callNumber ((UBYTE*)data->edtbuf);			
	  break;
	  
	case INFO_KCD_HUP:
	case INFO_KCD_RIGHT:
		pin_emergency_call = FALSE;

		/* SPR#1746 - SH - Now use identifier to return to previous context.
		 * If the editor handle is not NULL, the editor is still hanging around.
		 * We want to restart the editor, so we'll destroy it first. */
		 
		if (pin_editor_window)
		{
#ifdef NEW_EDITOR
			AUI_pin_Destroy(pin_editor_window);
#else
			editor_destroy(pin_editor_window);
#endif
			pin_editor_window = NULL;
		}

		/* SPR#1746 - SH - For most identifiers, the number can just be passed to pin_main as
		 * an event.  However, INSERT_CARD and CARD_REJECTED actually
		 * correspond to the pin_main events NO_SIM_CARD and INVALID_CARD
		 * respectively.  Make this conversion */
		if (identifier==INSERT_CARD)
			identifier = NO_SIM_CARD;
		else if (identifier==CARD_REJECTED)
			identifier = INVALID_CARD;
// Nov 24, 2005, a0876501, DR: OMAPS00045909
		else if (identifier == SHOW_IMEI_INVALID)
			identifier = INVALID_IMEI;
//x0pleela 18 Oct, 2006 DR: OMAPS00099660
//Added the following code inside the SIM_PERS flag
#ifdef SIM_PERS			
				//x0pleela 30 Aug, 2006 DR: OMAPS00091250
		else if( identifier == NO_MEPD_DATA )
			identifier = NO_MEPD;
#endif

		/* Restart the appropriate editor */
		SEND_EVENT(win, identifier, 0, data);		
		break;
    }

  return 1;
}
/*******************************************************************************

 $Function:	pins_loadEditDefault

 $Description:	fill up editor-sttribut with default
 
 $Returns:		
 
 $Arguments:		
				
*******************************************************************************/
//GW-SPR#844 - Zero editor data structure to reset all values to a known state.

/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
void pins_loadEditDefault (T_AUI_EDITOR_DATA *editor_data, USHORT TitleId, USHORT Identifier)
{
		TRACE_FUNCTION ("pins_loadEditDefault()");
		AUI_edit_SetDefault(editor_data);
		AUI_edit_SetDisplay(editor_data, PASSWORD_EDITOR, COLOUR_EDITOR_XX, EDITOR_FONT);
		AUI_edit_SetMode(editor_data, ED_MODE_HIDDEN, ED_CURSOR_UNDERLINE);
		AUI_edit_SetEvents(editor_data, Identifier, TRUE, FOREVER, (T_AUI_EDIT_CB)pins_editor_cb);
		if (pin1Flag EQ TRUE)   // June 16, 2005  REF: CRR 31267  x0021334
			AUI_edit_SetTextStr(editor_data, TxtSoftOK, TxtDelete, TitleId, NULL); //display RSK as delete
		else																  
			AUI_edit_SetTextStr(editor_data, TxtSoftOK, TxtSoftBack, TitleId, NULL); // display RSK as back
		AUI_edit_SetAltTextStr(editor_data, 4, TxtNull,  TRUE, TxtNull);

		return;
}
#else /* NEW_EDITOR */
void pins_loadEditDefault (T_EDITOR_DATA *editor_data)
{
		TRACE_EVENT ("pins_loadEditDefault()");
		memset(editor_data,0x00,sizeof(T_EDITOR_DATA));
		
		editor_attr_init(&editor_data->editor_attr, PASSWORD_EDITOR, edtCurBar1, NULL, NULL, 0, COLOUR_EDITOR_XX);

		editor_data->hide			    = FALSE;
	    editor_data->Identifier	       = 0;  /* optional */
	    editor_data->mode		    = PIN_SECURITY;
		editor_data->destroyEditor	    = TRUE;
		editor_data->LeftSoftKey	  = TxtSoftSelect;
		editor_data->AlternateLeftSoftKey   = TxtNull;
		editor_data->RightSoftKey	  = TxtSoftBack;
		editor_data->TextId		 = '\0';  
		editor_data->TextString 	  = NULL;  
		editor_data->min_enter		     = 1;  // Avoid to return empty strings
	    editor_data->timeout	      = FOREVER;
		editor_data->Callback		  = (T_EDIT_CB)pins_editor_cb;

}
#endif /* NEW_EDITOR */


//Clear PIN area
void pin_rectClear( MfwRect *win )
{
	
	dspl_Clear(win->px,win->py,win->px+win->sx-1,win->py+win->sy-1);
}
void pin_skClear( void )
{
	MfwRect skRect;
	Mmi_layout_softkeyArea( &skRect );
	pin_rectClear( &skRect );
}

// June 16, 2005  REF: CRR 31267  x0021334
// Call back function to display editor after info dialog
void pin1_cb_function (T_MFW_HND win, UBYTE identifier, UBYTE reason)
{
	TRACE_FUNCTION ("pin1_cb_function");

	// Post SIM_LOCKED_EMR_EDITOR event to start the editor
	SEND_EVENT(win, SIM_LOCKED_EMR_EDITOR, 0, 0);
}
/*******************************************************************************

 $Function:	getBootUpState

 $Description:	 returns the current state during bootup
 
 $Returns:		T_BOOTUP_STATE
 
 $Arguments:		None

//xashmic 21 Sep 2006, OMAPS00095831
*******************************************************************************/
T_BOOTUP_STATE getBootUpState(void)
{
	return BootUpState;
}
//x0pleela 21 Feb, 2007  ER: OMAPS00122561
#ifdef FF_PHONE_LOCK
/*******************************************************************************
 $Function:		phLock_Enable_Lock
 $Description:	sets the global flag to the network lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int phLock_Enable_Lock (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
    T_MFW_HND idle_win = mfwParent( mfw_header() );
    T_MFW_HND win = phlock_setting_pin_create(idle_win);
    UBYTE phlock_status, auto_phlock_status;
    T_MFW_WIN * win_data = NULL;
    T_pin * pin_data = NULL;
	
       TRACE_FUNCTION("phLock_Enable_Lock"); 
	   
    if(win != NULL) 
    {
	win_data = ((T_MFW_HDR *)win)->data;
	pin_data = (T_pin *)win_data->user;

	//x0pleela 23 May, 2007  DR: OMAPS00132483
	//stop the audio file if playing
#ifdef FF_MMI_AUDIO_PROFILE				
	if( mfwAudPlay)
	{
		// Stopping the current ring tone.
		#ifdef FF_MIDI_RINGER  
			mfw_ringer_stop(sounds_midi_ringer_stop_cb);
		#endif
	}
#endif //FF_MMI_AUDIO_PROFILE

	//check the status of Phone lock
    	phlock_status= mfw_phlock_get_lock_status(MFW_PH_LOCK);
    	//check the status of Automatic Phone lock
    	auto_phlock_status = mfw_phlock_get_autolock_status(MFW_AUTO_PH_LOCK);
    	
	//x0pleela 28 May, 2007  DR: OMAPS132483
	//set the phonelock and auto ph lock status to TRUE if lock is enabled
	if( phlock_status EQ MFW_PH_LOCK_DISABLE)
		mfw_set_Phlock_status(FALSE);
	else
		mfw_set_Phlock_status(TRUE);

	if( auto_phlock_status EQ MFW_PH_LOCK_DISABLE)
		mfw_set_Auto_Phlock_status(FALSE);
	else
		mfw_set_Auto_Phlock_status(TRUE);
	
    	pin_data->set_state = ENABLE;

	if( (phlock_status EQ MFW_PH_LOCK_DISABLE) && 
	     (auto_phlock_status EQ MFW_PH_LOCK_DISABLE))/*if Phone lock is disabled*/
	{	
       	SEND_EVENT(pin_data->pin_win,TXT_PH_LOCK_ALL,0,pin_data);	
     	}
	else 
	        SEND_EVENT(pin_data->pin_win,PH_LOCK_ALREADY_ENDIS,0,pin_data);
    }
	return 1;
}

/*******************************************************************************
 $Function:		phLock_Lock
 $Description:	sets the global flag to the network lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int phLock_Lock (void)
{
    T_MFW_HND idle_win = mfwParent( mfw_header() );
    T_MFW_HND win = phlock_setting_pin_create(idle_win);
    UBYTE slock_status;
    T_MFW_WIN * win_data = NULL;
    T_pin * pin_data = NULL;
	T_MFW_SS_RETURN ret;
	T_DISPLAY_DATA display_info;
	
       TRACE_FUNCTION("phLock_Lock"); 

    if(win != NULL) 
    {
	win_data = ((T_MFW_HDR *)win)->data;
	pin_data = (T_pin *)win_data->user;

//x0pleela 23 May, 2007  DR: OMAPS00132483
	//stop the audio file if playing
#ifdef FF_MMI_AUDIO_PROFILE				
	if( mfwAudPlay)
	{
		// Stopping the current ring tone.
		#ifdef FF_MIDI_RINGER  
			mfw_ringer_stop(sounds_midi_ringer_stop_cb);
		#endif
	}
#endif //FF_MMI_AUDIO_PROFILE

    	slock_status= mfw_phlock_get_lock_status(MFW_PH_LOCK);

	if(slock_status EQ MFW_PH_LOCK_DISABLE) /*if Phone lock is enabled*/
      {	
        ret = mfw_phlock_enable_lock(NULL, MFW_PH_LOCK); 

		if ( ret == MFW_SS_FAIL)
		{	
		        SEND_EVENT(pin_data->pin_win,PH_LOCK_EN_FAIL,0,pin_data);
		}
		else if( ret == MFW_EXCT)
		{
			dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull,TxtPleaseWait,TxtNull, COLOUR_STATUS);
			dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)NULL, FOREVER, KEY_CLEAR | KEY_LEFT );
			phlock_info_dialog (pin_data->pin_win, &display_info);
		}
         	else
         	{
         		//x0pleela 29 May, 2007  DR: OMAPS00132483
         		//set the phlock status to TRUE
         		mfw_set_Phlock_status( TRUE );
             		SEND_EVENT(pin_data->pin_win,PH_LOCK_SUCC,0,pin_data);
    	}
    	}
	return 1;
    }
	return 0;
}

/*******************************************************************************
 $Function:		phLock_UnLock
 $Description:	sets the global flag to the network lock
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int phLock_UnLock (void)
{
    T_MFW_HND idle_win = mfwParent( mfw_header() );
    T_MFW_HND win = phlock_setting_pin_create(idle_win);
    UBYTE slock_status;
    T_MFW_WIN * win_data = NULL;
    T_pin * pin_data = NULL;
	
       TRACE_FUNCTION("phLock_UnLock"); 

    if(win != NULL) 
    {
	win_data = ((T_MFW_HDR *)win)->data;
	pin_data = (T_pin *)win_data->user;

	//x0pleela 23 May, 2007  DR: OMAPS00132483
		//stop the audio file if playing
#ifdef FF_MMI_AUDIO_PROFILE				
	if( mfwAudPlay)
	{
		// Stopping the current ring tone.
		#ifdef FF_MIDI_RINGER  
			mfw_ringer_stop(sounds_midi_ringer_stop_cb);
		#endif
	}
#endif //FF_MMI_AUDIO_PROFILE

    	slock_status= mfw_phlock_get_lock_status(MFW_PH_LOCK);

    	pin_data->set_state = DISABLE;

	if(slock_status EQ MFW_PH_LOCK_ENABLE) /*if Phone lock is disabled*/
    {	
        SEND_EVENT(pin_data->pin_win,TXT_PH_LOCK_ALL,0,pin_data);	
     }
    else 
        SEND_EVENT(pin_data->pin_win,PH_LOCK_ALREADY_ENDIS,0,pin_data);
    	}
	return 1;
}

/*******************************************************************************
 $Function:		phLock_Automatic_On
 $Description:	sets automaticPhLock flag to ON
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int phLock_Automatic_On (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
	T_MFW_HND idle_win = mfwParent( mfw_header() );
    	T_MFW_HND win = phlock_setting_pin_create(idle_win);
	UBYTE slock_status;
	T_MFW_WIN * win_data = NULL;
	T_pin * pin_data = NULL;
	
	TRACE_FUNCTION("phLock_Automatic_On");
	autoPhLock_menu = TRUE;
	   
    if(win != NULL) 
    {
	win_data = ((T_MFW_HDR *)win)->data;
	pin_data = (T_pin *)win_data->user;

//x0pleela 23 May, 2007  DR: OMAPS00132483
	//stop the audio file if playing
#ifdef FF_MMI_AUDIO_PROFILE				
	if( mfwAudPlay)
	{
		// Stopping the current ring tone.
		#ifdef FF_MIDI_RINGER  
			mfw_ringer_stop(sounds_midi_ringer_stop_cb);
		#endif
	}
#endif //FF_MMI_AUDIO_PROFILE

	slock_status = mfw_phlock_get_autolock_status(MFW_AUTO_PH_LOCK);

    	pin_data->set_state = ENABLE;

	if(slock_status EQ MFW_PH_LOCK_DISABLE) /*if Phone lock is disabled*/
    {	
        SEND_EVENT(pin_data->pin_win,TXT_PH_LOCK_ALL,0,pin_data);	
     }
    else 
        SEND_EVENT(pin_data->pin_win,PH_LOCK_ALREADY_ENDIS,0,pin_data);
    	}
	return 1;
}

/*******************************************************************************
 $Function:		phLock_Automatic_Off
 $Description:	sets automaticPhLock flag to OFF
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int phLock_Automatic_Off (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
	int status;

	TRACE_FUNCTION("phLock_Automatic_Off"); 

	//x0pleela 23 May, 2007  DR: OMAPS00132483
		//stop the audio file if playing
#ifdef FF_MMI_AUDIO_PROFILE				
	if( mfwAudPlay)
	{
		// Stopping the current ring tone.
		#ifdef FF_MIDI_RINGER  
			mfw_ringer_stop(sounds_midi_ringer_stop_cb);
		#endif
	}
#endif //FF_MMI_AUDIO_PROFILE

	status = mfw_phlock_disable_autoLock(MFW_AUTO_PH_LOCK);
	if( status == MFW_SS_OK )
	{
		//x0pleela 09 Mar, 2007  DR: OMAPS00129014	
		//set the flag to FALSE
		phlock_auto = FALSE;	
		
		//x0pleela 28 May, 2007   DR: OMAPS00132483
		//Set the auto phone lock status to FALSE
		mfw_set_Auto_Phlock_status(FALSE);
		
		mmi_phlock_show_info(0, TxtAutoLockDisable, TxtSuccess, NULL);
	}
	else if ( status == MFW_SS_ALRDY_DIS )
		mmi_phlock_show_info(0, TxtPhoneLock, TxtAlreadyDisabled, NULL);   
	else
		mmi_phlock_show_info(0, TxtAutoLockDisable, TxtFailed, NULL);   

      return 1;
}

/*******************************************************************************
 $Function:		phLock_Change_UnlockCode
 $Description:	
 $Returns:		none
 $Arguments:	none
*******************************************************************************/
int phLock_Change_UnlockCode (struct MfwMnuTag * m, struct MfwMnuItemTag * i)
{
T_MFW_HND idle_win = mfwParent( mfw_header());
    T_MFW_HND win = phlock_setting_pin_create(idle_win);
    T_MFW_WIN * win_data = NULL;
    T_pin * pin_data = NULL;
    int status, auto_lock_status;
   	TRACE_FUNCTION("MmiPins:phLock_Change_UnlockCode");

	if(win != NULL)	/* x0039928 - Lint warning removal */
	{
		//x0pleela 23 May, 2007  DR: OMAPS00132483
			//stop the audio file if playing
#ifdef FF_MMI_AUDIO_PROFILE				
	if( mfwAudPlay)
	{
		// Stopping the current ring tone.
		#ifdef FF_MIDI_RINGER  
			mfw_ringer_stop(sounds_midi_ringer_stop_cb);
		#endif
	}
#endif //FF_MMI_AUDIO_PROFILE

		win_data = ((T_MFW_HDR *)win)->data;
		pin_data = (T_pin *)win_data->user;
		pin_data->set_state = CHANGE_PIN;
		status = mfw_phlock_get_lock_status(MFW_PH_LOCK);
		auto_lock_status = mfw_phlock_get_autolock_status(MFW_AUTO_PH_LOCK);
		if( ( status == MFW_PH_LOCK_ENABLE) ||
			auto_lock_status == MFW_PH_LOCK_ENABLE) 
		{
			SEND_EVENT(pin_data->pin_win,PH_LOCK_STATUS,0,pin_data);
		}
		else
	    	{
		    	SEND_EVENT(pin_data->pin_win,PH_LOCK_REQ_OLD,0,pin_data);
	    	}
	}
	return 1;
}


/*******************************************************************************
 $Function:		mmi_phlock_en_dis_verify
 $Description:	performs the operation of enabling/disabling and verifying a given
 				lock type after the input of the password
 $Returns:		none
 $Arguments:	none
*******************************************************************************/

static void mmi_phlock_en_dis_verify(T_MFW_HND win)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data
	T_MFW_SS_RETURN ret;
	T_DISPLAY_DATA display_info;

	TRACE_FUNCTION("mmi_phlock_en_dis_verify()");
  if((pin_data->set_state != ENABLE) && (pin_data->set_state != DISABLE))
	{	
              
	       TRACE_FUNCTION("We're verifying SIMLock");
	     
              SEND_EVENT(pin_data->pin_win,PH_LOCK_REQ_NEW,0,pin_data);
              
       }
  else if(pin_data->set_state EQ ENABLE)
   {	 
		TRACE_FUNCTION("MmiPins:Enable Lock now");
 		if( autoPhLock_menu )
 		{
			ret = mfw_phlock_enable_lock((U8*)pin_data->old_pin, MFW_AUTO_PH_LOCK); 
 		}
		else
		{
			ret = mfw_phlock_enable_lock((U8*)pin_data->old_pin, MFW_PH_LOCK); 
		}
		if ( ret == MFW_SS_FAIL)
		{	
		        SEND_EVENT(pin_data->pin_win,PH_LOCK_ENDIS_FAIL,0,pin_data);
		}
		else if( ret == MFW_EXCT)
		{
			dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull,TxtPleaseWait,TxtNull, COLOUR_STATUS);
			dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)NULL, FOREVER, KEY_CLEAR | KEY_LEFT );
			phlock_info_dialog (pin_data->pin_win, &display_info);
		}
         	else
     		{
			if( autoPhLock_menu )
			{
				//x0pleela 09 Mar, 2007  DR: OMAPS00129014
				//set the flag to TRUE
				phlock_auto = TRUE;

				//x0pleela 28 May, 2007   DR: OMAPS00132483
				//Set the auto phone lock status to TRUE
				mfw_set_Auto_Phlock_status(TRUE);
	             		SEND_EVENT(pin_data->pin_win,PH_LOCK_AUTO_SUCC,0,pin_data);
			}
			else
			{
				//x0pleela 28 May, 2007   DR: OMAPS00132483
				//Set the phone lock status to TRUE
				mfw_set_Phlock_status(TRUE);
	             		SEND_EVENT(pin_data->pin_win,PH_LOCK_ENDSUCC,0,pin_data);
			}
     		}
   }
   else  if(pin_data->set_state EQ DISABLE)
   { 	
   TRACE_FUNCTION("MmiPins:Disable Lock now");
   		ret = mfw_phlock_disable_lock((U8*)pin_data->old_pin,MFW_PH_LOCK);
		if (ret == MFW_SS_FAIL)
		{	
			SEND_EVENT(pin_data->pin_win,PH_LOCK_ENDIS_FAIL,0,pin_data);
		}
        	else
        	{
			//x0pleela 28 May, 2007   DR: OMAPS00132483
			//Set the phone lock status to FALSE
			mfw_set_Phlock_status(FALSE);
			
	       	SEND_EVENT(pin_data->pin_win,PH_LOCK_ENDSUCC,0,pin_data);
        	}
   }

}


/*******************************************************************************
 $Function:		mmi_phlock_change_pin
 $Description:	Performs the change password for a given lock type
 $Returns:		success or failure
 $Arguments:	lock type, oldpassword, new password
*******************************************************************************/

void mmi_phlock_change_pin(T_MFW_HND win,int type,char* oldpsw,char* newpsw)
{
    T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
    T_pin * pin_data = (T_pin *)win_data->user;

	TRACE_FUNCTION("mmi_phlock_change_pin()");
    TRACE_EVENT_P2(" old pasword%s new password%s ",oldpsw,newpsw);
     if(mfw_phlock_change_lock_code(type,oldpsw,newpsw) !=MFW_SS_OK)
     	{
     	TRACE_EVENT("mmi_phlock_change_pin: FAILED");
       SEND_EVENT(pin_data->pin_win,PH_LOCK_NEW_ENDISFAIL,0,pin_data);
     	}
    else
    	{
    	     	TRACE_EVENT("mmi_phlock_change_pin: SUCCESS");
        SEND_EVENT(pin_data->pin_win,PH_LOCK_NEW_ENDSUCC,0,pin_data);
    	}
}

/*******************************************************************************

 $Function:     mmi_phlock_show_info

 $Description: Display the Dialog

 $Returns:

 $Arguments:

*******************************************************************************/
static MfwHnd mmi_phlock_show_info(T_MFW_HND parent, int str1, int str2, T_VOID_FUNC callback)
{
	T_DISPLAY_DATA display_info;

	TRACE_FUNCTION ("mmi_phlock_show_info()");

	/*
	** Create a timed dialog to display the Message "Failed"
	*/
	dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, str1, str2, COLOUR_STATUS);
	dlg_initDisplayData_events( &display_info, callback, THREE_SECS, KEY_LEFT | KEY_CLEAR | KEY_HUP);
	return phlock_info_dialog(parent, &display_info);
}


/*******************************************************************************

 $Function:	phlock_setting_pin_create
 $Description:	Creation of an instance for the Settings PIN main dialog.
				Type of dialog : SINGLE_DYNAMIC
				Top Window must be available at any time, only one instance.
 $Returns:		window
 $Arguments:	parent window
*******************************************************************************/
T_MFW_HND phlock_setting_pin_create (T_MFW_HND parent_window)
{

  T_pin * data = (T_pin *)ALLOC_MEMORY (sizeof (T_pin));
  T_MFW_WIN	* win;

  data->pin_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)phlock_setting_pin_win_cb);

  TRACE_FUNCTION("MmiPins:phlock_setting_pin_create");

  set_pin_windows = data->pin_win;

  if (data->pin_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  data->mmi_control.dialog    = (T_DIALOG_FUNC)phlock_setting_pin_main;
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_win)->data;
  win->user		      = (void *) data;

  /*
   * Create any other handler
   */

  data->sim_handle = sim_create(data->pin_win,E_SIM_ALL_SERVICES,(MfwCb)sim_event_cb_setting);

  /*
   * Initialise
   */
 data->set_state = DEFAULT;
 data->puk_request = FALSE;


  mfwSetSignallingMethod(1);//mfw focus handling
  winShow(data->pin_win);//focus on settings:PIN/PIN2 Change/act/Deac


  /*
   * return window handle
   */
  return data->pin_win;
}
/*******************************************************************************

 $Function:	phlock_setting_pin_win_cb 
 $Description:	Callback function for main windows in settings
 $Returns:		Status int
 $Arguments:	event, window
*******************************************************************************/
static int phlock_setting_pin_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
  TRACE_FUNCTION("phlock_setting_pin_win_cb()");
  if (event EQ MfwWinVisible)
  {
    /*
     * Top Window has no output
     */
	/* NDH : Removed to prevent Blue Screen on Pin Entry */
	return 1;
  }
  return 0;

}

/*******************************************************************************

 $Function:	phlock_setting_pin_main 
 $Description:	PIN Settings Dialog Handling function
 $Returns:		none
 $Arguments:	win, event, value, parameters
*******************************************************************************/
void phlock_setting_pin_main(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user;//pin main data

	TRACE_FUNCTION("phlock_setting_pin_main()");

	 switch(event)
	 {
	case PH_LOCK_ALREADY_ENDIS:
	case PH_LOCK_STATUS:
       case PH_LOCK_REQ_OLD:
   	case PH_LOCK_REQ_NEW:
       case INPUT_NEW_PH_LOCK_AGAIN:	
       case NEW_PH_LOCK_FAIL:
       case PH_LOCK_NEW_ENDISFAIL:
       case PH_LOCK_NEW_ENDSUCC:
       case TXT_PH_LOCK_ALL:
       case PH_LOCK_ENDSUCC:
	case PH_UNLOCK_REQ:
	case PH_LOCK_AUTO_SUCC:
	case PH_LOCK_SUCC:
	case PH_LOCK_ENDIS_FAIL:
				  phlock_sett_pin_mess(win,event);
				  break;
	 }

	 switch(event)
	 {
                 case TXT_ENTER_PHLOCK:
	 			TRACE_EVENT("phlock_setting_pin_main: TXT_ENTER_PHLOCK");
                    		pin_data->pin_case = INPUT_PH_LOCK;
				phlock_sett_pin_edit(win,INPUT_PH_LOCK);
                            break;

                   case TXT_ENTER_NEW_PHLOCK:
                               pin_data->pin_case = INPUT_NEW_PH_LOCK;
				   phlock_sett_pin_edit(win,INPUT_NEW_PH_LOCK);
                                break;  

                   case TXT_ENTER_NEW_PHLOCK_AGAIN:
                               pin_data->pin_case = INPUT_NEW_PH_LOCK_AGAIN;
				   phlock_sett_pin_edit(win,INPUT_NEW_PH_LOCK_AGAIN);
				   break;      

                  case NEW_PH_LOCK_END:
                                    mmi_phlock_change_pin(win,MFW_PH_LOCK,(char*)pin_data->old_pin,(char*)pin_data->new_pin);
                              break; 				   

		case PH_LOCK_END:
			TRACE_EVENT("phlock_setting_pin_main:PH_LOCK_END");
			
			//x0pleela 15 May, 2007 DR: OMAPS00127483
			//When ringer for either incoming call or alarm is playing in phone locked state, Audio usues the DMA channels
			//which will be active. The DMA channels will be available only after the audio file is fully played.
			//This will cause that process to be blocked until the DMA channel becomes in-active and in turn if we try to 
			//query or access secure driver we are blocked until the audio file is completely played.
			//Since this is a hardware constraint, we found a workaround for this issue and are stopping the ringer  
			//either for incoming call or alarm before accessing secure driver for enabling or disbaling the phone lock.

			if( (( call_data.call_direction == MFW_CM_MTC ) &&  phlock_dialog_mtc_win_handle)
				|| (phlock_alarm) )
			{
				if( (!phlock_win_handle)		
			#ifdef FF_MMI_AUDIO_PROFILE				
					&& ( mfwAudPlay)
			#endif
					)
				{
				// Stopping the current ring tone.
				#ifdef FF_MIDI_RINGER  
					mfw_ringer_stop(sounds_midi_ringer_stop_cb);
				#endif
				}
			}
			 mmi_phlock_en_dis_verify(win);
                      break;
				   
	 
               case PH_LOCK_SETT_ABORT:
	 			TRACE_EVENT("phlock_setting_pin_main: PH_LOCK_SETT_ABORT");
				phlock_setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
				break;
				
		  default:
			  break;
	 }

}

/*******************************************************************************

 $Function:	phlock_sett_pin_mess 
 $Description:	help function for message dialog
 $Returns:		void
 $Arguments:	window, event
*******************************************************************************/
static void phlock_sett_pin_mess(T_MFW_HND win,USHORT event)
{

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	T_MFW_HND pin_mess_win;
	TRACE_FUNCTION("MmiPins:phlock_sett_pin_mess()");

	pin_mess_win = phlock_set_pin_mess_create(pin_data->pin_win);
	if(pin_mess_win)
	{
		SEND_EVENT(pin_mess_win,event,0,pin_data);
	}
}


/*******************************************************************************

 $Function:	phlock_set_pin_mess_create
 $Description:	Creation of an instance  for the PIN Message dialog settings
				Type of dialog : SINGLE_DYNAMIC
 $Returns:		void
 $Arguments:	parent window
*******************************************************************************/
T_MFW_HND phlock_set_pin_mess_create(T_MFW_HND parent_window)
{
  T_pin_mess * data = (T_pin_mess *)ALLOC_MEMORY (sizeof (T_pin_mess));
  T_MFW_WIN	* win;

  data->pin_mess_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)phlock_set_pin_mess_win_cb);

  TRACE_FUNCTION("MmiPins: phlock_set_pin_mess_create");

  if (data->pin_mess_win EQ 0)
    return 0;

  /*
   * Create window handler
   */
  data->mmi_control.dialog    = (T_DIALOG_FUNC)phlock_set_pin_messages;
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_mess_win)->data;
  win->user		      = (void *) data;

  /*
   * return window handle
   */
  return data->pin_mess_win;
}


/*******************************************************************************

 $Function:	phlock_set pin_mess_destroy
 $Description:	Destroy the pin message dialog settings
 $Returns:		void
 $Arguments:	window
*******************************************************************************/
void phlock_set_pin_mess_destroy  (T_MFW_HND own_window)
{
  T_pin_mess * data;
  T_MFW_WIN * win;


  TRACE_FUNCTION("MmiPins: phlock_set_pin_mess_destroy()");

  if (own_window)
  {
	  win = ((T_MFW_HDR *)own_window)->data;
	  data = (T_pin_mess *)win->user;

	  if(data)
	  {

      /*
       * Delete WIN Handler
       */
	  win_delete (data->pin_mess_win);
	      FREE_MEMORY((void*)data,(sizeof(T_pin_mess)));
	  }
   }
}

/*******************************************************************************

 $Function:	phlock_set_pin_mess_win_cb
 $Description:	Callback function for message windows
 $Returns:		void
 $Arguments:	event, window
*******************************************************************************/
static int phlock_set_pin_mess_win_cb (T_MFW_EVENT event, T_MFW_WIN * win)
{
TRACE_FUNCTION("phlock_set_pin_mess_win_cb()");
  /*
   * Top Window has no output
   */
  return 1;
}


/*******************************************************************************

 $Function:	phlock_set_pin_messages
 $Description:	Message Dialog for PIN/PUK handling in settings
 $Returns:		void
 $Arguments:	win, event, value, parameter
*******************************************************************************/
void phlock_set_pin_messages(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_mess * mess_data = (T_pin_mess *)win_data->user;

	T_DISPLAY_DATA display_info;
	T_pin * pin_data = (T_pin *)parameter;
  TRACE_FUNCTION("Mmi.Pins:phlock_set_pin_messages");

  /*
   * depending on signal
   */
	
  switch (event)
  {
	case PH_LOCK_ALREADY_ENDIS:
	case PH_LOCK_NEW_ENDSUCC:
    	case PH_LOCK_ENDSUCC:
	case PH_LOCK_AUTO_SUCC:
	case PH_LOCK_SUCC:
	case PH_LOCK_STATUS:		
   	case NEW_PH_LOCK_FAIL:
       case PH_LOCK_NEW_ENDISFAIL:
       case PH_LOCK_ENDIS_FAIL:
	case PH_LOCK_EN_FAIL:

		dlg_initDisplayData_TextId( &display_info, TxtNull, TxtNull, TxtNull, TxtNull,  COLOUR_STATUS_PINS);
		
		switch(event)
		{
		case PH_LOCK_ALREADY_ENDIS:
			pin_data->pin_case = PH_LOCK_ALREADY_ENDIS;
			display_info.TextId = TxtPhoneLock;

		  	if(pin_data->set_state == ENABLE)
				display_info.TextId2 = TxtAlreadyEnabled;
			else if(pin_data->set_state == DISABLE)
			  	display_info.TextId2 = TxtAlreadyDisabled;
			  
			  break;

	         case PH_LOCK_NEW_ENDSUCC:
			if(phlock_win_handle)
				phlock_win_handle = NULL;

			if( phlock_kbd_handle)
				phlock_kbd_handle = NULL;

          		  pin_data->pin_case = PH_LOCK_NEW_ENDSUCC;
			  display_info.TextId = TxtPhoneLock;
			  display_info.TextId2 = TxtPsLockChanged;
			  break;
			  
		  case PH_LOCK_ENDSUCC:
		  	TRACE_EVENT("phlock_set_pin_messages: PH_LOCK_ENDSUCC");
			if(phlock_win_handle)
				phlock_win_handle = NULL;


			if( phlock_kbd_handle)
				phlock_kbd_handle = NULL;

				//x0pleela 28 May, 2007  DR: OMAPS00132483
				//get the phone lock status 
				if( mfw_get_Phlock_status() )
      				{
      					TRACE_EVENT("LOCK ENABLED");
	      				//For USB MS
	      				if( mmi_get_usbms_enum() )
	      				{
					#ifdef FF_MMI_USBMS      			
						//unregister USB enumeration
						TRACE_EVENT("USB de-enumeration");
			      			mfw_usbms_enum_control(MFW_USB_NO_ENUM , MFW_USB_TYPE_ALL);
					#endif /*FF_MMI_USBMS*/
	      				}
					//For Headset
					if( mmi_get_Headset_Reg() )
					{
						#ifdef FF_MMI_AUDIO_PROFILE	
							//unregister headset
							//mfw_headset_unregister();
							TRACE_EVENT("headset unregister");
							mfw_hook_unregister();
						#endif /*FF_MMI_AUDIO_PROFILE*/
					}
					pin_data->pin_case = PH_LOCK_ENDSUCC;
				}
				else
				{
					TRACE_EVENT("LOCK DISABLED");
					//For USB MS
					if( mmi_get_usbms_enum() )
					{
					#ifdef FF_MMI_USBMS      
			      			//register USB enumeration
			      			TRACE_EVENT("USB re-enumeration");
		      				mfw_usbms_enum_control(MFW_USB_ENUM , MFW_USB_TYPE_ALL);
					#endif /*FF_MMI_USBMS*/
					}
					//For Headset
					if( mmi_get_Headset_Reg() )
					{
						#ifdef FF_MMI_AUDIO_PROFILE	
							//register headset
							//mfw_headset_register();
						if(call_data.win_calling OR call_data.win_incoming OR call_data.calls.numCalls)
							{
								TRACE_EVENT("headset register");
								mfw_hook_register();
							}
						#endif /*FF_MMI_AUDIO_PROFILE*/
					}	
						pin_data->pin_case = PH_LOCK_SUCCESS;
							
				}
				display_info.TextId = TxtPhone;
				display_info.Identifier = pin_data->pin_case;
	
		 if(pin_data->set_state == ENABLE)
			  {
			  	display_info.TextId2 = TxtLockActivated;
				TRACE_EVENT("phlock_set_pin_messages: PH_LOCK_ENDSUCC: Activated");
			  }
			  else if(pin_data->set_state == DISABLE)
			  {
			  	display_info.TextId2 = TxtLockDeactivated;
				TRACE_EVENT("phlock_set_pin_messages: PH_LOCK_ENDSUCC: Deactivated");
			  }

			  break;				  
		
		case PH_LOCK_AUTO_SUCC:
			TRACE_EVENT("phlock_set_pin_messages: PH_LOCK_AUTO_SUCC");
			if(phlock_win_handle)
				phlock_win_handle = NULL;


			if( phlock_kbd_handle)
				phlock_kbd_handle = NULL;

			//x0pleela 29 May, 2007  DR: OMAPS00132483
				//get the auto phone lock status 
				if( mfw_get_Auto_Phlock_status() )
			  {
			  	display_info.TextId = TxtAutoPhone;
			    	pin_data->pin_case = PH_LOCK_AUTO_SUCC;
				autoPhLock_menu = FALSE;
			  }
			  if(pin_data->set_state == ENABLE)
			  {
			  	display_info.TextId2 = TxtLockActivated;
			  }
			  else if(pin_data->set_state == DISABLE)
			  {
			  	display_info.TextId2 = TxtLockDeactivated;
			  }
			break;

			case PH_LOCK_SUCC:
		  	TRACE_EVENT("set_pin_msgs: PH_LOCK_SUCC");
			if(phlock_win_handle)
				phlock_win_handle = NULL;

			
			if( phlock_kbd_handle)
				phlock_kbd_handle = NULL;

				//x0pleela 28 May, 2007  DR: OMAPS00132483
				//get the phone lock status 
				if( mfw_get_Phlock_status() )
      				{
      					TRACE_EVENT("LOCK ENABLED");
	      				//For USB MS
	      				if( mmi_get_usbms_enum() )
	      				{
					#ifdef FF_MMI_USBMS      			
						//unregister USB enumeration
						TRACE_EVENT("USB de-enumeration");
			      			mfw_usbms_enum_control(MFW_USB_NO_ENUM , MFW_USB_TYPE_ALL);
					#endif /*FF_MMI_USBMS*/
	      				}
					//For Headset
					if( mmi_get_Headset_Reg() )
					{
						#ifdef FF_MMI_AUDIO_PROFILE	
							//unregister headset
							//mfw_headset_unregister();
							TRACE_EVENT("headset unregister");
							mfw_hook_unregister();
						#endif /*FF_MMI_AUDIO_PROFILE*/
					}
				}
				else
				{
					TRACE_EVENT("LOCK DISABLED");
					//For USB MS
					if( mmi_get_usbms_enum() )
					{
					#ifdef FF_MMI_USBMS      
			      			//register USB enumeration
			      			TRACE_EVENT("USB re-enumeration");
		      				mfw_usbms_enum_control(MFW_USB_ENUM , MFW_USB_TYPE_ALL);
					#endif /*FF_MMI_USBMS*/
					}
					//For Headset
					if( mmi_get_Headset_Reg() )
					{
						#ifdef FF_MMI_AUDIO_PROFILE	
							//register headset
							//mfw_headset_register();
						if(call_data.win_calling OR call_data.win_incoming OR call_data.calls.numCalls)
							{
								TRACE_EVENT("headset register");
								mfw_hook_register();
							}
						#endif /*FF_MMI_AUDIO_PROFILE*/
					}	
					}
			
			display_info.TextId = TxtLockActivated;
			pin_data->pin_case = PH_LOCK_ENDSUCC;
			 display_info.Identifier = pin_data->pin_case;
			  
			  break;	
  
	case PH_LOCK_STATUS:
		pin_data->pin_case = PH_LOCK_STATUS;
		display_info.TextId = TxtPhone;
      		switch(mfw_phlock_get_lock_status(MFW_PH_LOCK)) 
      		{
                      case MFW_PH_LOCK_DISABLE:
				display_info.TextId2 = TxtLockDisabled;
				break;
                      case  MFW_PH_LOCK_ENABLE:
				display_info.TextId2 = TxtLockEnabled; 
				break;
           	}
     		break;

	case PH_LOCK_NEW_ENDISFAIL:
	{
			if(phlock_win_handle)
				phlock_win_handle = NULL;

			if( phlock_kbd_handle)
				phlock_kbd_handle = NULL;

	pin_data->pin_case = FAILURE_PASS_CHG;
	display_info.TextId = TxtCodeInc;
	display_info.Identifier = pin_data->pin_case;

	}
			  break;
 	case NEW_PH_LOCK_FAIL:
			if(phlock_win_handle)
				phlock_win_handle = NULL;
			
			if( phlock_kbd_handle)
				phlock_kbd_handle = NULL;

			
              	pin_data->pin_case = INPUT_NEW_PH_LOCK;
			  display_info.TextId = TxtPsLockConfWrong;
			  display_info.TextId2 = TxtPsLockConfwrong2;
			  break;

       case PH_LOCK_ENDIS_FAIL:
	   	TRACE_EVENT("phlock_set_pin_msgs:PH_LOCK_ENDIS_FAIL");
		//x0pleela 28 May, 2007  DR: OMAPS00132483
		//get the phone lock status 
		if ( mfw_get_Phlock_status() ) 
			pin_data->pin_case = PH_LOCK_ENDIS_FAIL;
		else
			pin_data->pin_case = PH_LOCK_FAILURE;
		display_info.Identifier = pin_data->pin_case;

		if (autoPhLock_menu )
			autoPhLock_menu = FALSE;

		  display_info.TextId = TxtCodeInc;
		break;	

	case PH_LOCK_EN_FAIL:
		pin_data->pin_case = PH_LOCK_FAILURE;
		display_info.TextId = TxtNotLocked;
		break;
		
		 	}

    {
	dlg_initDisplayData_events( &display_info, (T_VOID_FUNC)phlock_set_pin_info_cb, THREE_SECS, KEY_LEFT );
	display_info.Identifier = pin_data->pin_case;
	phlock_set_pin_mess_destroy(mess_data->pin_mess_win);

	phlock_info_dialog(pin_data->pin_win,&display_info); //information screen
	 dspl_Enable(1);
    }
	break;
		
	case TXT_PH_LOCK_ALL:
	case PH_UNLOCK_REQ:
		TRACE_EVENT(":phlock_set_pin_msgs: TXT_PH_LOCK_ALL");
       	pin_data->display_id1 = TxtEnterPhUnlockCode;
 		phlock_set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PHLOCK,0,pin_data);
		break;
	case PH_LOCK_REQ_OLD:
              pin_data->display_id1 = TxtEnterOldPsLock;
		phlock_set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_PHLOCK,0,pin_data);
		break;

	case PH_LOCK_REQ_NEW:
		pin_data->display_id1 = TxtEnterPsLockNew;
		phlock_set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_NEW_PHLOCK,0,pin_data);
		break;

       case INPUT_NEW_PH_LOCK_AGAIN:
              pin_data->display_id1 = TxtEnterPsLockconf;
		phlock_set_pin_mess_destroy(mess_data->pin_mess_win);
		SEND_EVENT(pin_data->pin_win,TXT_ENTER_NEW_PHLOCK_AGAIN,0,pin_data);
              break;
	default:
		break;
  }
		
}


/*******************************************************************************

 $Function:	phlock_set_pin_info_cb
 $Description:	settings pin information screen call back
 $Returns:		void
 $Arguments:	win, identifier, reason
*******************************************************************************/
void phlock_set_pin_info_cb(T_MFW_HND win, USHORT identifier, UBYTE reasons)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user;

	TRACE_FUNCTION("MmiPins: phlock_set_pin_info_cb()");

	switch(identifier)
	{

		case PH_LOCK_ENDSUCC:					
				TRACE_EVENT("PH_LOCK_ENDSUCC");
				
				//x0pleela 28 May, 2007  DR: OMAPS00132483
				//get the phone lock status 
				if( mfw_get_Phlock_status() )
	      			{
	      			TRACE_EVENT("phlock_set_pin_info_cb: LOCK ENABLED");

						//For USB MS
	      				if( mmi_get_usbms_enum() )
	      				{
					#ifdef FF_MMI_USBMS      			
						//unregister USB enumeration
						TRACE_EVENT("USB de-enumeration");
			      			mfw_usbms_enum_control(MFW_USB_NO_ENUM , MFW_USB_TYPE_ALL);
					#endif /*FF_MMI_USBMS*/
	      				}
						
					pin_data->set_state = DISABLE;
					identifier = pin_data->pin_case = PH_UNLOCK_REQ;
					SEND_EVENT(pin_data->pin_win,identifier,0,NULL);				
	           		}
												
			break;

			case PH_LOCK_ENDIS_FAIL:
				TRACE_EVENT("PH_LOCK_ENDIS_FAIL");
				dspl_Enable(1);
				pin_data->set_state = DISABLE;
				identifier = pin_data->pin_case = PH_UNLOCK_REQ;
				
				//x0pleela 15 May, 2007 DR: OMAPS00127483
				//Starting the ringer again for either incoming call or alarm if the user has entered wrong unlocking pasword.
				if( ( ( ( call_data.call_direction == MFW_CM_MTC ) &&  (phlock_dialog_mtc_win_handle) ) || ( phlock_alarm ) )
					&& (phlock_win_handle)
					#ifdef FF_MMI_AUDIO_PROFILE				
						&& ( !mfwAudPlay)
					#endif	
				)
				{
					if( call_data.call_direction == MFW_CM_MTC ) 
					{
					#ifdef FF_MIDI_RINGER  
						mfw_ringer_start(AS_RINGER_MODE_IC, TRUE, sounds_midi_ringer_start_cb);
					#endif
					}
					else if ( phlock_alarm )
					{
					#ifdef FF_MIDI_RINGER  
						mfw_ringer_start(AS_RINGER_MODE_ALARM, TRUE, sounds_midi_ringer_start_cb);
					#endif
					}
					
				}
				SEND_EVENT(pin_data->pin_win,identifier,0,NULL);				
			break;

			case PH_LOCK_SETT_ABORT:      
				SEND_EVENT(pin_data->pin_win,identifier,0,NULL);//pin_main data !!
				break;				
			

		default:		
		switch (reasons)
		{
			case INFO_KCD_LEFT:
			case INFO_KCD_RIGHT:
		
			case INFO_TIMEOUT:
			{
			        pin_skClear();
				phlock_setting_pin_destroy(pin_data->pin_win);// destroy pin settings dialog
				//x0pleela 07 Apr, 2007  ER: OMAPS00122561
				if( phlock_alarm) 
				{
					TRACE_EVENT("phlock_set_pin_info_cb: INFO_TIMEOUT ");
					if( phlock_alarm_win_handle )
						winShow(phlock_alarm_win_handle);
				}	
				if( call_data.call_direction == MFW_CM_MTC )
				{
					if( phlock_mtc_win_handle )
						winShow(phlock_mtc_win_handle);
					
					if( phlock_dialog_mtc_win_handle )
						winShow(phlock_dialog_mtc_win_handle);
				}
			}
		
			break;
		}
			break;
	}
	return;
}

/*******************************************************************************

 $Function:	phlock_sett_pin_edit
 $Description:	help function for editor dialog
 $Returns:		none
 $Arguments:	window, event
*******************************************************************************/
static void phlock_sett_pin_edit(T_MFW_HND win, USHORT event)
{

//open the editor for entering the pin

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin * pin_data = (T_pin *)win_data->user; // pin main data

	T_MFW_HND pin_edt_win;


TRACE_FUNCTION("phlock_sett_pin_edit()");
	pin_edt_win = phlock_set_pin_edt_create(pin_data->pin_win);



    if(pin_edt_win)
	{
		SEND_EVENT(pin_edt_win,event,0,pin_data);
	}
 


}


/*******************************************************************************

 $Function:	phlock_set_pin_edt_create
 $Description:	Creation of an instance  for the PIN Editor dialog settings
				Type of dialog : SINGLE_DYNAMIC
 $Returns:		window
 $Arguments:	parent window
*******************************************************************************/
T_MFW_HND phlock_set_pin_edt_create (T_MFW_HND parent_window)
{
  T_pin_edt * data = (T_pin_edt *)ALLOC_MEMORY (sizeof (T_pin_edt));
  T_MFW_WIN * win;

  data->pin_edt_win = win_create (parent_window, 0, MfwWinVisible, (T_MFW_CB)phlock_set_pin_edt_win_cb);

  TRACE_FUNCTION("MmiPins:phlock_set_pin_edt_create");

  if (data->pin_edt_win EQ 0)
    return 0;
  
	phlock_win_handle = data->pin_edt_win;
  /*
   * Create window handler
   */
  data->mmi_control.dialog    = (T_DIALOG_FUNC)phlock_set_pin_editor;
  data->mmi_control.data      = data;
  data->parent_win = parent_window;
  win			      = ((T_MFW_HDR *)data->pin_edt_win)->data;
  win->user		      = (void *) data;

  /*
   * Create any other handler
   */

  data->tim_out_handle = tim_create(data->pin_edt_win,TIMEOUT,(T_MFW_CB)phlock_pin_edt_tim_out_cb);

/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
  data->editor = ATB_edit_Create(&data->editorPinAttr,0);
#else /* NEW_EDITOR */
  data->editor_handle = edt_create(data->pin_edt_win,&data->editpinAttr,0,0);
#endif /* NEW_EDITOR */
  data->kbd_handle = kbd_create(data->pin_edt_win,KEY_ALL,(T_MFW_CB)phlock_set_pin_kbd_cb);
phlock_kbd_handle = data->kbd_handle;

  data->kbd_long_handle = kbd_create(data->pin_edt_win,KEY_ALL | KEY_LONG,(T_MFW_CB)phlock_set_pin_edt_kbd_long_cb);
  /*
   * return window handle
   */
  return data->pin_edt_win;
}

/*******************************************************************************

 $Function:	phlock_set_pin_edt_win_cb
 $Description:	Callback function for editor windows
 $Returns:		status int
 $Arguments:	event, window
*******************************************************************************/
static int phlock_set_pin_edt_win_cb (T_MFW_EVENT event,T_MFW_WIN * win)
{
  T_pin_edt * edt_data = (T_pin_edt *)win->user;//pin edt data
  T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
  T_pin     * pin_data = (T_pin *)win_pin->user; // pin main data

  TRACE_FUNCTION("phlock_set_pin_edt_win_cb");

  if (event EQ MfwWinVisible)
  {

  /* SPR#1428 - SH - New Editor changes */
  #ifdef NEW_EDITOR
	ATB_edit_Show(edt_data->editor);
	
	if (edt_data->editor->update!=ED_UPDATE_TRIVIAL)
	{
		/* Set the colour for drawing title */

		resources_setTitleColour(COLOUR_EDITOR);

		dspl_Clear(0,0, SCREEN_SIZE_X-1, edt_data->editor->attr->win_size.py-1);

		/* Title */

		if(pin_emergency_call == TRUE)
		{					
			PROMPT(0,0,0,TxtEmergency);
		}
		else
		{
		   	PROMPT(0,0,0,pin_data->display_id1);
#ifdef SIM_PERS
			if( pin_data->display_id2)
				PROMPT(0,20,0,pin_data->display_id2);
#endif
		}

		/* Soft keys */
		
		if ((strlen((char*)edt_data->pin) >= MIN_PIN) && (strlen((char*)edt_data->pin) < (MAX_PIN + 1)))
		{
				if(!(edt_data->gsm_state))	  /* usual way for PIN 4 digits     */
				{
#ifdef SIM_PERS
					if(pin_data->display_id1 == TxtPhoneBlocked)
						softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);
					else
#endif
					softKeys_displayId(TxtSoftOK,TxtDelete,0, COLOUR_EDITOR_XX);
				}
			}
		//xvilliva - Added the below "if" and moved the existing "if" in to "else". "if" avoids "delete" key display.
		if((strlen((char*)edt_data->pin) == 0))//  May 13, 2004        REF: CRR 13623  xvilliva
		{
			TRACE_EVENT("clear softkey 16 - zero length");
			softKeys_displayId(TxtNull,TxtNull,0, COLOUR_EDITOR_XX);												
		}
		else if((strlen((char*)edt_data->pin) < MIN_PIN) && (edt_data->emergency_call != TRUE))
		{
			TRACE_EVENT("clear softkey 16");	
			softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);												
		}
#ifdef SIM_PERS
		else if((strlen((char*)edt_data->pin) < MIN_PIN) && (edt_data->emergency_call == TRUE))
		{
			TRACE_EVENT("clear softkey 16");	
			if(pin_emergency_call == TRUE)
				softKeys_displayId(TxtSoftCall,TxtDelete,0, COLOUR_EDITOR_XX);												
			else
			softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);												
		}
#endif
	}
	
	edt_data->editor->update = ED_UPDATE_DEFAULT;
	
#else /* NEW_EDITOR */
	pin_icons();
   	PROMPT(INFO_TEXT_X,INFO_TEXT_Y,0,pin_data->display_id1);
   	
  TRACE_FUNCTION("softkey 6");
	softKeys_displayId(TxtNull,TxtDelete,0, COLOUR_EDITOR_XX);
#endif /* NEW_EDITOR */
 
    return 1;
  }
  return 0;
}



/*******************************************************************************

 $Function:	phlock_set_pin_editor
 $Description:	Pin editor Dialog Signal Handling function
 $Returns:		void
 $Arguments:	window, event, value, parameters
*******************************************************************************/
static void phlock_set_pin_editor(T_MFW_HND win, USHORT event, SHORT value, void * parameter)
{
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;

    T_pin * pin_data = (T_pin *)parameter;//pin main data

	edt_data->pin_case_edit = pin_data->pin_case;

	TRACE_FUNCTION("MmiPins:phlock_set_pin_editor");

  /*
   * depending on event
   */
  switch (event)
  {
	
//x0pleela 06 Mar, 2007 ER: OMAPS00122561
#ifdef FF_PHONE_LOCK
	case INPUT_PH_LOCK:
	case INPUT_NEW_PH_LOCK:
	case INPUT_NEW_PH_LOCK_AGAIN:
#endif /*FF_PHONE_LOCK*/
		//SPR#717 - GW - Wrong structures being cleared
		memset(edt_data->pin, '\0', sizeof(edt_data->pin));/* initial string  */
		memset(edt_data->puk, '\0', sizeof(edt_data->puk));
		memset(edt_data->new_pin, '\0', sizeof(edt_data->new_pin));
		memset(edt_data->old_pin, '\0', sizeof(edt_data->old_pin));

		/* Set up pin entry attributes */
		/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
		AUI_edit_SetAttr( &edt_data->editorPinAttr, PIN_EDIT_RESET, COLOUR_EDITOR_XX, EDITOR_FONT, 0, ED_CURSOR_UNDERLINE, ATB_DCS_ASCII, (UBYTE *)edt_data->edtbuf, MAX_DIG);
		clear_edit_array(edt_data);	     /*    clear editor buffer	    */
		edt_data->editor_index = 0;
		ATB_edit_Init(edt_data->editor);
		ATB_edit_Show(edt_data->editor);
#else /* NEW_EDITOR */
		editor_attr_init( &edt_data->editpinAttr, PIN_EDIT_RESET, edtCurBar1,0,(char*)edt_data->edtbuf,MAX_DIG,COLOUR_EDITOR_XX);
		clear_edit_array(edt_data);	     /*    clear editor buffer	    */
		edt_data->editor_index = 0;
		edtShow(edt_data->editor_handle);
#endif /* NEW_EDITOR */

		winShow(edt_data->pin_edt_win);

		break;

	default:
		break;
  }
}



/*******************************************************************************

 $Function:	set_pin_kbd_cb
 $Description:	Callback function for keyboard settings pin
 $Returns:		status int
 $Arguments:	event, keyboard control block
*******************************************************************************/
static int phlock_set_pin_kbd_cb (T_MFW_EVENT event,T_MFW_KBD *  kc)
{
    T_MFW_HND win = mfw_parent(mfw_header());
	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;

	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;//pin edt data

	T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
	T_pin * pin_data = (T_pin *)win_pin->user; // pin main data

	char timer = TRUE;

	timStop(edt_data->tim_out_handle);/* stop entering timer      */

	TRACE_FUNCTION("MmiPins:phlock_set_pin_kbd_cb");

//x0pleela 12 Mar, 2007  ER: OMAPS00122561	
#if defined ( SIM_PERS) || defined (FF_PHONE_LOCK)
 	#if defined (SIM_PERS ) AND !defined (FF_PHONE_LOCK)
		if ( !perm_blocked) 
	#elif defined (FF_PHONE_LOCK ) AND !defined (SIM_PERS)
		if ((mfw_phlock_get_lock_status(MFW_PH_LOCK) == MFW_PH_LOCK_DISABLE) ||
			(mfw_phlock_get_autolock_status(MFW_AUTO_PH_LOCK) == MFW_PH_LOCK_DISABLE) )
	#elif defined (SIM_PERS ) AND defined (FF_PHONE_LOCK)
		if( ( !perm_blocked) || 
			(mfw_phlock_get_lock_status(MFW_PH_LOCK) == MFW_PH_LOCK_DISABLE) 	||
			(mfw_phlock_get_autolock_status(MFW_AUTO_PH_LOCK) == MFW_PH_LOCK_DISABLE))
	#endif
	
#endif /* SIM_PERS OR FF_PHONE_LOCK */
	{
	switch(kc->code)
	{
		case KCD_0:
		case KCD_1:
		case KCD_2:
		case KCD_3:
		case KCD_4:
		case KCD_5:
		case KCD_6:
		case KCD_7:
		case KCD_8:
		case KCD_9:
		case KCD_STAR:
//x0pleela 12 Mar, 2007  ER: OMAPS00122561
			if(edt_data->editor_index < PH_MAX_DIG)
			{
				/* xreddymn OMAPS00083495 Jul-04-2006 
				 * Limit PIN1, PIN2 entries to 8 digits.
				 */
				if((
					 (edt_data->pin_case_edit==INPUT_PH_LOCK)  ||
					(edt_data->pin_case_edit==INPUT_NEW_PH_LOCK)  ||
					(edt_data->pin_case_edit==INPUT_NEW_PH_LOCK_AGAIN)
					)
					&&(edt_data->editor_index>=4) 

					&& (!edt_data->gsm_state))
					return MFW_EVENT_CONSUMED;
				else
				{
					if(kc->code EQ KCD_STAR)
						edt_data->pin[edt_data->editor_index] = STAR;
					else
						edt_data->pin[edt_data->editor_index] = '0' + kc->code;

					/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
					ATB_edit_AsciiChar(edt_data->editor, '*', TRUE);
#else /* NEW_EDITOR */
					edtChar(edt_data->editor_handle,'*');/* hide security code */
#endif /* NEW_EDITOR */

					edt_data->editor_index++;
					check_set_pins(win,edt_data); /* digits check depends on status pin_case */
					if(edt_data->gsm_state)
						pin_data->gsm_state = edt_data->gsm_state;
				}
			}
			winShow(edt_data->pin_edt_win);
			break;

		case KCD_HASH:
		case KCD_LEFT:

			if(pin_emergency_call == TRUE)
			{
				callNumber((UBYTE *)pin_emerg_call);
				pin_emergency_call = FALSE;
#ifdef FF_PHONE_LOCK
				break;
#endif //FF_PHONE_LOCK
			}

			
			if(!(strncmp((char*)edt_data->pin,"**052*",IDENT_GSM_2))||!(strncmp((char*)edt_data->pin,"**05*",IDENT_GSM_1)))

			{
				edt_data->pin[edt_data->editor_index] = HASH;
				// SPR#1428 - SH - New Editor changes 
#ifdef NEW_EDITOR
				ATB_edit_AsciiChar(edt_data->editor, edt_data->pin[edt_data->editor_index], TRUE);
#else // NEW_EDITOR 
				edtChar(edt_data->editor_handle,edt_data->pin[edt_data->editor_index]);
#endif // NEW_EDITOR 
				edt_data->editor_index++;
			}

			

			// We save the pin2 entered in to this global variable which we
			// use while calling sAT_PlusCLCK(), while locking or unlocking ALS. 					
			memset(g_pin2,0,MAX_PIN+1);
			if(edt_data->pin_case_edit EQ INPUT_PIN2 || edt_data->pin_case_edit EQ INPUT_NEW_PIN2)
				strncpy(g_pin2,(char*)edt_data->pin,MAX_PIN);//xvilliva SPR17291
			switch(edt_data->pin_case_edit)
			{
//x0pleela 06 Mar, 2007 ER: OMAPS00122561
#ifdef FF_PHONE_LOCK
		 case INPUT_PH_LOCK:
#endif /*FF_PHONE_LOCK*/
				
					TRACE_EVENT_P1("pin_emergency_call = %d", pin_emergency_call);
					TRACE_EVENT("When 'Call' is pressed!");

					/* PIN is long enough, finish editing */
					
					if ((strlen((char*)edt_data->pin) >= MIN_PIN)  && !(edt_data->gsm_state))
					{
						clear_edit_array(edt_data);	    /*	   clear editor array */
						timer = FALSE;
						strncpy((char*)edt_data->old_pin,(char*)edt_data->pin,MAX_PIN);
						strncpy((char*)pin_data->old_pin, (char*)edt_data->old_pin,MAX_PIN);
						
     						 if(edt_data->pin_case_edit EQ INPUT_PH_LOCK)
                         			{
	                        			TRACE_EVENT("phlock_set_pin_kbd_cb: INPUT_PH_LOCK");
							if(phlock_win_handle)
								phlock_win_handle = NULL;
							
							if( phlock_kbd_handle)
								phlock_kbd_handle = NULL;

						    phlock_set_pin_edt_destroy(edt_data->pin_edt_win);
							SEND_EVENT(pin_data->pin_win,PH_LOCK_END,0,pin_data);
						}
						
					}
					else
					{
						if(kc->code EQ KCD_HASH)
						{	
							if (!(edt_data->gsm_state))	/* could become gsm */
							{
								check_pins(win,edt_data);
								if(edt_data->gsm_state)
									pin_data->gsm_state = edt_data->gsm_state;
							}
							else /* finish gsm string */
							{
								timer = FALSE;
								if(edt_data->pin_case_edit EQ INPUT_PIN1)
									pin_data->pin_case = PIN1_REQ_OLD;
								else
									pin_data->pin_case = PIN2_REQ_OLD;
								//xrashmic 1 Jul, 2006 OMAPS00075784
								//Blue screen fix - Wrong window was being sent
								gsm_sec_execute_set(pin_data->pin_win,edt_data);	    /* execute gsm string */

							}
						}
					}
					break;

					
//x0pleela 06 Mar, 2007 ER: OMAPS00122561
#ifdef FF_PHONE_LOCK
				case INPUT_NEW_PH_LOCK:
#endif /*FF_PHONE_LOCK*/					
					if ((strlen((char*)edt_data->pin) >= MIN_PIN)  && !(edt_data->gsm_state))
					{
						clear_edit_array (edt_data);			  /* clear editor array */
						timer = FALSE;
						strncpy((char*)edt_data->new_pin, (char*)edt_data->pin,MAX_PIN);	  /*  store new pin	  */
						strncpy((char*)pin_data->new_pin, (char*)edt_data->new_pin,MAX_PIN);
						
				//x0pleela 06 Mar, 2007  ER: OMAPS00122561
				#ifdef  FF_PHONE_LOCK
					if(pin_data->pin_case EQ INPUT_NEW_PH_LOCK)
					{
                            		phlock_set_pin_edt_destroy(edt_data->pin_edt_win);
                                   	SEND_EVENT(pin_data->pin_win,INPUT_NEW_PH_LOCK_AGAIN,0,NULL);
                                 	}
                             #endif /* FF_PHONE_LOCK */							
						
					}
					else
					{
						if(kc->code EQ KCD_HASH)
						{	
							if(!(edt_data->gsm_state)) /* could become gsm	    */
							{
								check_pins(win,edt_data);
								if(edt_data->gsm_state)
						       		pin_data->gsm_state = edt_data->gsm_state;
							}
							else /* finish gsm string  */
							{
								timer = FALSE;

								if(edt_data->pin_case_edit EQ INPUT_NEW_PIN)
									pin_data->pin_case = PIN1_REQ_OLD;
								else
									pin_data->pin_case = PIN2_REQ_OLD;
								//xrashmic 1 Jul, 2006 OMAPS00075784
								//Blue screen fix - Wrong window was being sent
								gsm_sec_execute_set(pin_data->pin_win,edt_data);	    /* execute gsm string */

							}
						}
					}
					break;
//x0pleela 06 Mar, 2007 ER: OMAPS00122561
#ifdef FF_PHONE_LOCK
				case INPUT_NEW_PH_LOCK_AGAIN:
#endif	/*FF_PHONE_LOCK*/					
				
						if ((strlen((char*)edt_data->pin) >= MIN_PIN) && !(edt_data->gsm_state))
						{
							clear_edit_array (edt_data);			  /* clear editor array */
							timer = FALSE;
							if(strcmp((char*)edt_data->pin, (char*)pin_data->new_pin) EQ 0) /* compare PINs successfull*/
							{
								strncpy((char*)pin_data->new_pin, (char*)edt_data->pin,MAX_PIN);
								
								//x0pleela 06 Mar, 2007 ER: OMAPS00122561
							#ifdef FF_PHONE_LOCK
								if (pin_data->pin_case EQ INPUT_NEW_PH_LOCK_AGAIN)
                                                   	{
                                                     		phlock_set_pin_edt_destroy(edt_data->pin_edt_win);
                                                    		SEND_EVENT(pin_data->pin_win, NEW_PH_LOCK_END,0,pin_data);
                                                   	}
							#endif /*FF_PHONE_LOCK*/								
								
							}
							else
							{									/* new PIN != new PIN again */

								
								//x0pleela 06 Mar, 2007 ER: OMAPS00122561
							#ifdef FF_PHONE_LOCK
								if (pin_data->pin_case EQ INPUT_NEW_PH_LOCK_AGAIN)
                                                   	{
                                                     		phlock_set_pin_edt_destroy(edt_data->pin_edt_win);
                                                    		SEND_EVENT(pin_data->pin_win, NEW_PH_LOCK_FAIL,0,pin_data);
                                                   	}
							#endif /*FF_PHONE_LOCK*/									
								
							}
						}
						else
						{
							if(kc->code EQ KCD_HASH)
							{
								if (!(edt_data->gsm_state)) /* could become gsm	    */
								{
									check_pins(win,edt_data);
									if(edt_data->gsm_state)
							       		pin_data->gsm_state = edt_data->gsm_state;
								}
								else /* finish gsm string  */
								{
									timer = FALSE;
									if(edt_data->pin_case_edit EQ INPUT_NEW_PIN_AGAIN)
										pin_data->pin_case = PIN1_REQ_OLD;
									else
										pin_data->pin_case = PIN2_REQ_OLD;
								//xrashmic 1 Jul, 2006 OMAPS00075784
								//Blue screen fix - Wrong window was being sent
								gsm_sec_execute_set(pin_data->pin_win,edt_data);	    /* execute gsm string */

								}
							}
						}
						break;
					
					default:
						break;
				}
				break;
				
/* KCD_HUP */
			case KCD_HUP:
				if( edt_data->pin_case_edit != INPUT_PUK1)//xvilliva SPR13623
				{
				clear_edit_array(edt_data);
				timer = FALSE;
//x0pleela 30 Mar, 2007  ER OMAPS00122561
#ifdef FF_PHONE_LOCK
			if( (!phlock_win_handle) || (pin_data->set_state != DISABLE) )
				{
#endif //FF_PHONE_LOCK				
				phlock_set_pin_edt_destroy(edt_data->pin_edt_win);
	    		SEND_EVENT(pin_data->pin_win,PH_LOCK_SETT_ABORT,0,NULL); // abort settings menu
#ifdef FF_PHONE_LOCK
				}
#endif //FF_PHONE_LOCK	    		
				}
				break;

/* KCD RIGHT */

			case KCD_RIGHT: 	
			//nm, go back to the submenu if there is no character on the screen
				if(strlen((char*)edt_data->pin) == 0 && edt_data->pin_case_edit != INPUT_PUK1)//xvilliva SPR13623
				{
					clear_edit_array(edt_data);
					timer = FALSE;
//x0pleela 30 Mar, 2007  ER OMAPS00122561
#ifdef FF_PHONE_LOCK
			if( (!phlock_win_handle) || (pin_data->set_state != DISABLE) )
				{
#endif //FF_PHONE_LOCK
					phlock_set_pin_edt_destroy(edt_data->pin_edt_win);
		    		SEND_EVENT(pin_data->pin_win,PH_LOCK_SETT_ABORT,0,NULL); // abort settings menu
					return 1;			    
#ifdef FF_PHONE_LOCK
				}
#endif //FF_PHONE_LOCK					
				}

				if(edt_data->editor_index EQ 0)
					;
				else
					edt_data->editor_index--;

				edt_data->pin[edt_data->editor_index] = '\0';
				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				ATB_edit_DeleteLeft(edt_data->editor, TRUE); /* SPR#2342 - SH */
#else /* NEW_EDITOR */
				edtChar(edt_data->editor_handle,ecBack);/* delete character    */
#endif /* NEW_EDITOR */

				if(strlen((char*)edt_data->pin)<MIN_PIN)
				{
				}

				edt_data->emergency_call = FALSE;
				if(edt_data->pin_case_edit EQ INPUT_PUK1)  /* special case ?? */
					winShow(edt_data->pin_edt_win);
				else
				{
					check_set_pins(win,edt_data);	       /* check remain for emergency call  */
					winShow(edt_data->pin_edt_win);
				}
			    break;
			    
			default:
				break;
		}
	}
//x0pleela 12 Mar, 2007  ER: OMAPS00122561
#if defined (SIM_PERS) || defined ( FF_PHONE_LOCK )
	else
#ifdef FF_PHONE_LOCK
    		if((mfw_phlock_get_lock_status(MFW_PH_LOCK) == MFW_PH_LOCK_ENABLE) || 
			(mfw_phlock_get_autolock_status(MFW_AUTO_PH_LOCK) == MFW_PH_LOCK_ENABLE) )
#endif /*FF_PHONE_LOCK*/
	{
		switch(kc->code)
		{
		case KCD_0:
		case KCD_1:
		case KCD_2:
		case KCD_6:
		case KCD_8:
		case KCD_9:
			if(edt_data->editor_index < MAX_DIG)
			{
				edt_data->pin[edt_data->editor_index] = '0' + kc->code;

				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				ATB_edit_AsciiChar(edt_data->editor, '*', TRUE);
#else /* NEW_EDITOR */
				edtChar(edt_data->editor_handle,'*');/* hide security code */
#endif /* NEW_EDITOR */

				edt_data->editor_index++;
				check_set_pins(win,edt_data); /* digits check depends on status pin_case */
				if(edt_data->gsm_state)
					pin_data->gsm_state = edt_data->gsm_state;
			}
			winShow(edt_data->pin_edt_win);
			break;
				
	
		case KCD_LEFT:

			if(pin_emergency_call == TRUE)
			{
				callNumber((UBYTE *)pin_emerg_call);
				pin_emergency_call = FALSE;
			}
			break;

		case KCD_RIGHT: 	

//				if( edt_data->edtbuf == '\0' )
//					break;
				if(edt_data->editor_index EQ 0)
					;
				else
					edt_data->editor_index--;

				edt_data->pin[edt_data->editor_index] = '\0';
				/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
				ATB_edit_DeleteLeft(edt_data->editor, TRUE); /* SPR#2342 - SH */
#else /* NEW_EDITOR */
				edtChar(edt_data->editor_handle,ecBack);/* delete character    */
#endif /* NEW_EDITOR */

				if(strlen((char*)edt_data->pin)<MIN_PIN)
				{
				}

				edt_data->emergency_call = FALSE;
				if(edt_data->pin_case_edit EQ INPUT_PUK1)  /* special case ?? */
					winShow(edt_data->pin_edt_win);
				else
				{
					check_set_pins(win,edt_data);	       /* check remain for emergency call  */
					winShow(edt_data->pin_edt_win);
				}
			    break;

			default:
				break;
			}	
	}
#endif /* SIM_PERS  OR FF_PHONE_LOCK*/
	if (timer)
		tim_start(edt_data->tim_out_handle);/* start timer for entering */
	return 1;
}



/*******************************************************************************

 $Function:	phlock_set_pin_edt_kbd_long_cb
 $Description:	Callback function for keyboard long
 $Returns:		status int
 $Arguments:	event, keyboard control block
*******************************************************************************/
static int phlock_set_pin_edt_kbd_long_cb (T_MFW_EVENT event,T_MFW_KBD *  kc)
{
    T_MFW_HND win = mfw_parent(mfw_header());

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;//pin edt data

    TRACE_FUNCTION("MmiPins:phlock_set_pin_edt_kbd_long_cb");

    if ((event & KEY_CLEAR) && (event & KEY_LONG))
	{
			timStop(edt_data->tim_out_handle); /* stop entering timer	*/
			clear_edit_array(edt_data);
			memset(edt_data->pin,'\0',sizeof(edt_data->pin));/* initial string */
			
			/* SPR#1428 - SH - New Editor: string changed, update word-wrap*/
	#ifdef NEW_EDITOR
			ATB_edit_Refresh(edt_data->editor);
	#endif /* NEW_EDITOR */
			edt_data->editor_index = 0;
			edt_data->emergency_call = FALSE;
			winShow(edt_data->pin_edt_win);
	}

  return MFW_EVENT_CONSUMED;
}

/*******************************************************************************

 $Function:	phlock_pin_edt_tim_out_cb
 $Description:	Callback function for timer (watchdog entering)
 $Returns:		void
 $Arguments:	window handler event, timer control block 
 
*******************************************************************************/
static void phlock_pin_edt_tim_out_cb (T_MFW_EVENT event,T_MFW_TIM * t)
{
    T_MFW_HND win = mfw_parent(mfw_header());

	T_MFW_WIN * win_data = ((T_MFW_HDR *)win)->data;
	T_pin_edt * edt_data = (T_pin_edt *)win_data->user;

	T_MFW_WIN * win_pin =((T_MFW_HDR *)edt_data->parent_win)->data;
	T_pin * pin_data = (T_pin *)win_pin->user; // pin main data

    TRACE_FUNCTION("MmiPins:phlock_pin_edt_tim_out_cb");


    TRACE_FUNCTION("clear softkey 7");

	// clear the softkeys
	pin_skClear();
	clear_edit_array(edt_data);
	// clear the input
	
	/* SPR#1428 - SH - New Editor changes */
#ifdef NEW_EDITOR
	ATB_edit_ClearAll(edt_data->editor);
#else /* NEW_EDITOR */
	pin_rectClear( &edt_data->editpinAttr.win );
    memset(edt_data->pin, '\0', sizeof(edt_data->pin));/* initial string  */
#endif /* NEW_EDITOR */

	edt_data->editor_index = 0;
	edt_data->gsm_state = FALSE;
	pin_data->gsm_state = FALSE;

	winShow(edt_data->pin_edt_win);
}

/*******************************************************************************

 $Function:	phlock_setting_pin_destroy 
 $Description:	Destroy the settings pin main dialog.
 $Returns:		none
 $Arguments:	window
*******************************************************************************/
void phlock_setting_pin_destroy  (T_MFW_HND own_window)
{
  T_pin * data;
  T_MFW_WIN * win;

  if (own_window)
  {
	 TRACE_FUNCTION("MmiPins:phlock_setting_pin_destroy");

	 win = ((T_MFW_HDR *)own_window)->data;
     data = (T_pin *)win->user;

	 if(data)
	 {
      /*
       * Exit SIM and Delete SIM Handler
       */
	 sim_delete (data->sim_handle);

      /*
       * Delete WIN Handler
       */
	  set_pin_windows = 0;
      win_delete (data->pin_win);
      data->pin_win=0;
	if(data)
	 FREE_MEMORY((void *)data,(sizeof(T_pin)));
	 }
  }
}

/*******************************************************************************

 $Function:	phlock_set_pin_edt_destroy
 $Description:	Destroy the pin editor dialog
 $Returns:		none
 $Arguments:	window
*******************************************************************************/
void phlock_set_pin_edt_destroy(T_MFW_HND own_window)
{
  T_pin_edt * data ;
  T_MFW_WIN * win;

  if (own_window)
  {
	  TRACE_FUNCTION("MmiPins:phlock_set_pin_edt_destroy");

	  win = ((T_MFW_HDR *)own_window)->data;
	  data = (T_pin_edt *)win->user;

	  if(data)
	  {
      /*
       * Delete WIN Handler
       */
	      win_delete (data->pin_edt_win);
	      FREE_MEMORY((void *)data,(sizeof(T_pin_edt)));
	  }
   }
}
#endif /* FF_PHONE_LOCK */