phoneapp/phoneuicontrol/inc/cphonenumberentrymanager.h
changeset 77 2be0b271d017
parent 64 6aaf0276100e
equal deleted inserted replaced
72:c76a0b1755b9 77:2be0b271d017
    19 #ifndef CPONENUMBERENTRYMANAGER_H
    19 #ifndef CPONENUMBERENTRYMANAGER_H
    20 #define CPONENUMBERENTRYMANAGER_H
    20 #define CPONENUMBERENTRYMANAGER_H
    21 
    21 
    22 //INCLUDES
    22 //INCLUDES
    23 #include <e32base.h>
    23 #include <e32base.h>
    24 
       
    25 #include "cphonestate.h"
       
    26 #include "tphonecmdparamboolean.h"
    24 #include "tphonecmdparamboolean.h"
    27 #include "tphonecmdparamkeyevent.h"
    25 #include "tphonecmdparamkeyevent.h"
    28 
    26 
    29 class CPhoneCbaManager;
    27 class CPhoneUiCommandManager;
    30 class MPhoneViewCommandHandle;
    28 class MPhoneViewCommandHandle;
    31 class MPhoneStateMachine;
    29 class MPhoneStateMachine;
    32 class MPhoneCustomization;
    30 class MPhoneCustomization;
    33 class CPhoneState;
    31 class CPhoneState;
    34 class CEikonEnv;
    32 class CEikonEnv;
    38  *
    36  *
    39  * @lib phoneuicontrol
    37  * @lib phoneuicontrol
    40  * @since S60 v9.1
    38  * @since S60 v9.1
    41  */
    39  */
    42 NONSHARABLE_CLASS( CPhoneNumberEntryManager ) :  public CBase
    40 NONSHARABLE_CLASS( CPhoneNumberEntryManager ) :  public CBase
    43                                              
       
    44     {
    41     {
    45     public:
    42     public:
    46         
    43         
    47         /**
    44         /**
    48         * Creates new instance of CPhoneNumberEntryManager
    45         * Creates new instance of CPhoneNumberEntryManager
    49         * @param aState: Handle to cphonestate.
    46         * @param aState: Handle to cphonestate.
    50         * @param aStateMachine: a state machine
    47         * @param aStateMachine: a state machine
    51         * @param aViewCommandHandle: Handle to the PhoneUIView.
    48         * @param aViewCommandHandle: Handle to the PhoneUIView.
    52         * @param aCustomization: Handle to customization.
    49         * @param aCustomization: Handle to customization.
    53         * @param aCbaManager: Handle to cphonecbamanager.
    50         * @param aUiCommandManager: Handle to cphoneuicommandmanager.
    54         * @return CPhoneNumberEntryManager* object  
    51         * @return CPhoneNumberEntryManager* object  
    55         */
    52         */
    56         static CPhoneNumberEntryManager* NewL(
    53         static CPhoneNumberEntryManager* NewL(
    57                     CPhoneState* aState,
    54                     CPhoneState* aState,
    58                     MPhoneViewCommandHandle& aViewCommandHandle,
    55                     MPhoneViewCommandHandle& aViewCommandHandle,
    59                     MPhoneStateMachine& aStateMachine,
    56                     MPhoneStateMachine& aStateMachine,
    60                     MPhoneCustomization* aCustomization,
    57                     MPhoneCustomization* aCustomization,
    61                     CPhoneCbaManager& aCbaManager );
    58                     CPhoneUiCommandManager& aUiCommandManager );
    62         /**
    59         /**
    63         * Destructor.
    60         * Destructor.
    64         */
    61         */
    65         virtual ~CPhoneNumberEntryManager();    
    62         virtual ~CPhoneNumberEntryManager();    
    66         
    63         
    67     public:
    64     public:
    68 
    65 
    69         /**
    66         /**
    70         * Stores the number entry content to the cache
    67         * Stores the number entry content to the cache
    71         */
    68         */
    72         void StoreNumberEntryContentL();
    69         IMPORT_C void StoreNumberEntryContentL();
    73         
    70         
    74 
    71 
    75         /**
    72         /**
    76         * Check if number entry content is stored
    73         * Check if number entry content is stored
    77         * @param None
    74         * @param None
    78         * @return boolean value indicating that number entry content is stored
    75         * @return boolean value indicating that number entry content is stored
    79         */
    76         */
    80         TBool IsNumberEntryContentStored();
    77         IMPORT_C TBool IsNumberEntryContentStored();
    81         
    78         
    82         /**
    79         /**
    83         * Clears the number entry content cache
    80         * Clears the number entry content cache
    84         */        
    81         */        
    85         void ClearNumberEntryContentCache();
    82         IMPORT_C void ClearNumberEntryContentCache();
    86         
    83         
    87         /**
    84         /**
    88         * Set Number Entry visibility.
    85         * Set Number Entry visibility.
    89         * @param aVisible ETrue if numberentry is wanted to be shown
    86         * @param aVisible ETrue if numberentry is wanted to be shown
    90         *                 (Note ETrue will set NE CBA's)
    87         *                 (Note ETrue will set NE CBA's)
    91         *                 EFalse if numberentry isnt wanted to be shown
    88         *                 EFalse if numberentry isnt wanted to be shown
    92         *                 (Note EFalse doesnt affect to CBA's)
    89         *                 (Note EFalse doesnt affect to CBA's)
    93         */
    90         */
    94         void SetNumberEntryVisibilityL( TPhoneCmdParamBoolean aVisible );
    91         IMPORT_C void SetNumberEntryVisibilityL( TBool aVisible );
    95         
    92         
    96         /**
    93         /**
    97         * Check if number entry is used
    94         * Check if number entry is used
    98         * @return boolean value indicating that number entry is used
    95         * @return boolean value indicating that number entry is used
    99         */
    96         */
   100         TBool IsNumberEntryUsedL() const;
    97         IMPORT_C TBool IsNumberEntryUsedL() const;
   101         
    98         
   102         /**
    99         /**
   103         * Check if number entry is visible
   100         * Check if number entry is visible
   104         * @return boolean value indicating that number entry is visible
   101         * @return boolean value indicating that number entry is visible
   105         */
   102         */
   106         TBool IsNumberEntryVisibleL() const;
   103         IMPORT_C TBool IsNumberEntryVisibleL() const;
   107         
   104         
   108         /**
   105         /**
   109          * Returns phone number from the phone number entry.
   106          * Returns phone number from the phone number entry.
   110          * @return  Phone number
   107          * @return  Phone number
   111          */
   108          */
   112         HBufC* PhoneNumberFromEntryLC() const;
   109         IMPORT_C HBufC* PhoneNumberFromEntryLC() const;
   113         
       
   114         
       
   115         /**
       
   116         * Returns ETrue if alphanumeric characters are supported.
       
   117         * @param aKeyEvent Key event.
       
   118         * @return ETrue if alphanumeric chars are supported.
       
   119         */
       
   120         TBool IsAlphanumericSupportedAndCharInput(
       
   121                 const TKeyEvent& aKeyEvent ) const;
       
   122         
       
   123         /**
       
   124         * Handle state-specific behaviour when number entry is cleared
       
   125         */
       
   126         void HandleNumberEntryClearedL();
       
   127         
   110         
   128         /**
   111         /**
   129          * Internal number entry handling methods.
   112          * Internal number entry handling methods.
   130          */
   113          */
   131         void NumberEntryClearL() const;
   114         IMPORT_C void NumberEntryClearL() const;
   132         
       
   133     private:
       
   134         
   115         
   135         /**
   116         /**
   136         * Checks is given key contains numeric charaters or if customization is used
   117          * Returns request status, if return value is true then number
   137         * alphanumeir letters
   118          * entry visibility was set according to aVisibility if false
       
   119          * then nothing was done.
       
   120          */
       
   121         IMPORT_C TBool SetVisibilityIfNumberEntryUsedL( TBool aVisibility );
       
   122         
       
   123         /**
       
   124          * Request causes number entry removal only if visibility is false.
       
   125          */
       
   126         IMPORT_C void RemoveNumberEntryIfVisibilityIsFalseL();
       
   127         
       
   128         /**
       
   129          * Cache is cleared if there is some content in store.
       
   130          */
       
   131         IMPORT_C void ClearNumberEntryContentCacheIfContentStored();
       
   132         
       
   133         /**
       
   134         * Create call if in numberentry more that 2 number and Send key
       
   135         * Send manual control sequence
       
   136         * if 1-2 number in numberentry and Send key
   138         */
   137         */
   139         TBool IsValidAlphaNumericKey( const TKeyEvent& aKeyEvent,
   138         IMPORT_C void CallFromNumberEntryL();
   140                 TEventCode aEventCode );
   139         
       
   140         /**
       
   141         * Checks whether customized dialer view is active,
       
   142         * @return ETrue if customized dialer is active
       
   143         */
       
   144         IMPORT_C TBool IsCustomizedDialerVisibleL() const;
   141     
   145     
   142     private:
   146     private:
   143     
   147     
   144         /**
   148         /**
   145         * C++ default constructor.
   149         * C++ default constructor.
   147         CPhoneNumberEntryManager(
   151         CPhoneNumberEntryManager(
   148                 CPhoneState* aState,
   152                 CPhoneState* aState,
   149                 MPhoneViewCommandHandle& aViewCommandHandle,
   153                 MPhoneViewCommandHandle& aViewCommandHandle,
   150                 MPhoneStateMachine& aStateMachine,
   154                 MPhoneStateMachine& aStateMachine,
   151                 MPhoneCustomization* aCustomization,
   155                 MPhoneCustomization* aCustomization,
   152                 CPhoneCbaManager& aCbaManager );
   156                 CPhoneUiCommandManager& aUiCommandManager );
   153         
   157         
   154         /**
   158         /**
   155         * Symbian constructor
   159         * Symbian constructor
   156         */
   160         */
   157         void ConstructL();
   161         void ConstructL();
   160         
   164         
   161         CPhoneState* iState;
   165         CPhoneState* iState;
   162         MPhoneViewCommandHandle& iViewCommandHandle;
   166         MPhoneViewCommandHandle& iViewCommandHandle;
   163         MPhoneStateMachine& iStateMachine;
   167         MPhoneStateMachine& iStateMachine;
   164         MPhoneCustomization* iCustomization;
   168         MPhoneCustomization* iCustomization;
   165         CPhoneCbaManager& iCbaManager;
   169         CPhoneUiCommandManager& iUiCommandManager;
   166         
       
   167                 
   170                 
   168         /**
   171         /**
   169         * Cache for the number entry content
   172         * Cache for the number entry content
   170         */
   173         */
   171         HBufC* iNumberEntryContent;
   174         HBufC* iNumberEntryContent;