textinput/peninputsplititut/src/peninputsplititutwesternuistatenonpredict.cpp
changeset 0 eb1f2e154e89
child 7 a47de9135b21
equal deleted inserted replaced
-1:000000000000 0:eb1f2e154e89
       
     1 /*
       
     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0""
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  drop-down list control
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #include <AknFepGlobalEnums.h>
       
    20 #include <peninputsplititutnew.rsg>
       
    21 #include <e32keys.h>
       
    22 #include <peninputlayout.h>
       
    23 #include <peninputcommonbutton.h>
       
    24 #include <peninputrawkeybutton.h>
       
    25 
       
    26 #include "peninputsplititutwesternuistatenonpredict.h"
       
    27 #include "peninputsplititutuimgrbase.h"
       
    28 #include "peninputsplititutdatamgr.h"
       
    29 #include "peninputsplititutlayoutcontext.h"
       
    30 #include "peninputsplititutwindowmanager.h"
       
    31 
       
    32 
       
    33 // ============================ MEMBER FUNCTIONS =============================
       
    34 
       
    35 // ---------------------------------------------------------------------------
       
    36 // CWesternSplitItutUiStateNonPredict::NewL
       
    37 // ---------------------------------------------------------------------------
       
    38 //
       
    39 CWesternSplitItutUiStateNonPredict* CWesternSplitItutUiStateNonPredict::NewL(CSplitItutUiMgrBase* aOwner)
       
    40     {
       
    41     CWesternSplitItutUiStateNonPredict* self = new (ELeave) CWesternSplitItutUiStateNonPredict(aOwner);
       
    42     CleanupStack::PushL(self);
       
    43     self->ConstructL(); 
       
    44     CleanupStack::Pop(self);
       
    45     return self;
       
    46     }
       
    47 
       
    48 // ---------------------------------------------------------------------------
       
    49 // CWesternSplitItutUiStateNonPredict::~CWesternSplitItutUiStateNonPredict
       
    50 // ---------------------------------------------------------------------------
       
    51 //
       
    52 CWesternSplitItutUiStateNonPredict::~CWesternSplitItutUiStateNonPredict()
       
    53     {
       
    54     }
       
    55 
       
    56 // ---------------------------------------------------------------------------
       
    57 // CWesternSplitItutUiStateNonPredict::CWesternSplitItutUiStateNonPredict
       
    58 // ---------------------------------------------------------------------------
       
    59 //
       
    60 CWesternSplitItutUiStateNonPredict::CWesternSplitItutUiStateNonPredict(CSplitItutUiMgrBase* aOwner)
       
    61                                                             :CSplitItutUiStateBase(aOwner),
       
    62                                                              iConsumeLastKeyDown(EFalse)
       
    63     {
       
    64     }
       
    65 
       
    66 // ---------------------------------------------------------------------------
       
    67 // CWesternSplitItutUiStateNonPredict::OnEntryL
       
    68 // ---------------------------------------------------------------------------
       
    69 //
       
    70 void CWesternSplitItutUiStateNonPredict::OnEntryL()
       
    71     {
       
    72     TInt keypadResId = KInvalidResId;
       
    73     switch (iOwner->DataMgr()->InputMode())
       
    74         {
       
    75         case ENumber:
       
    76         	if( iOwner->DataMgr()->IsExistPlusChar() )
       
    77         		{
       
    78         		keypadResId = R_FINGER_INPUT_KEYPAD_NUMBER_WITH_PLUS;
       
    79         		}
       
    80         	else
       
    81         		{
       
    82         		keypadResId = R_FINGER_INPUT_KEYPAD_NUMBER;
       
    83         		}
       
    84             break;
       
    85         case ELatin:
       
    86             keypadResId = iOwner->DataMgr()->KeypadResourceId();
       
    87             break;
       
    88         default:
       
    89             break;                
       
    90         }
       
    91 
       
    92     // update resource id of keypad, candidate drop list
       
    93     iOwner->DataMgr()->NotifyChangeControlLayout(
       
    94         MItutPropertySubscriber::EItutPropertyKeypadResourceId, keypadResId);
       
    95 
       
    96     // for secret editor, there is no need to show navigation buttons
       
    97         {
       
    98         if (iOwner->DataMgr()->IsChinese())
       
    99             {
       
   100             iOwner->LayoutContext()->ShowArrowBtn(EBtnArrowLeft | EBtnArrowRight
       
   101                  | EBtnArrowUp| EBtnArrowDown);   
       
   102             if(iOwner->LayoutContext()->IsSecretEdtior())
       
   103                 {
       
   104                 CAknFepCtrlRawKeyButton * leftbtn;
       
   105                 CAknFepCtrlRawKeyButton * rightbtn;
       
   106                 CAknFepCtrlRawKeyButton * upbtn;
       
   107                 CAknFepCtrlRawKeyButton * downbtn;
       
   108                 leftbtn = static_cast<CAknFepCtrlRawKeyButton *>
       
   109                                             (iOwner->LayoutContext()->Control(ECtrlIdArrowLeft));
       
   110                 rightbtn = static_cast<CAknFepCtrlRawKeyButton *>
       
   111                                             (iOwner->LayoutContext()->Control(ECtrlIdArrowRight));
       
   112                 upbtn = static_cast<CAknFepCtrlRawKeyButton *>
       
   113                                             (iOwner->LayoutContext()->Control(ECtrlIdArrowUp));
       
   114                 downbtn = static_cast<CAknFepCtrlRawKeyButton *>
       
   115                                             (iOwner->LayoutContext()->Control(ECtrlIdArrowDown)); 
       
   116                 leftbtn->SetDimmed(ETrue);   
       
   117                 rightbtn->SetDimmed(ETrue);   
       
   118                 upbtn->SetDimmed(ETrue);   
       
   119                 downbtn->SetDimmed(ETrue);   
       
   120                 }
       
   121             }
       
   122         else
       
   123             {
       
   124             iOwner->LayoutContext()->ShowArrowBtn(EBtnArrowLeft | EBtnArrowRight);    
       
   125             if(iOwner->LayoutContext()->IsSecretEdtior())
       
   126                 {
       
   127                 CAknFepCtrlRawKeyButton * leftbtn;
       
   128                 CAknFepCtrlRawKeyButton * rightbtn;
       
   129                 leftbtn = static_cast<CAknFepCtrlRawKeyButton *>
       
   130                                             (iOwner->LayoutContext()->Control(ECtrlIdArrowLeft));
       
   131                 rightbtn = static_cast<CAknFepCtrlRawKeyButton *>
       
   132                                             (iOwner->LayoutContext()->Control(ECtrlIdArrowRight));
       
   133                 leftbtn->SetDimmed(ETrue);   
       
   134                 rightbtn->SetDimmed(ETrue);   
       
   135                 }
       
   136             }
       
   137         }
       
   138     }
       
   139 
       
   140 // ---------------------------------------------------------------------------
       
   141 // CWesternSplitItutUiStateNonPredict::OnExit
       
   142 // ---------------------------------------------------------------------------
       
   143 //
       
   144 void CWesternSplitItutUiStateNonPredict::OnExit()
       
   145     {
       
   146     iOwner->LayoutContext()->ShowArrowBtn(0);
       
   147     }
       
   148 
       
   149 // ---------------------------------------------------------------------------
       
   150 // CWesternSplitItutUiStateNonPredict::StateType
       
   151 // ---------------------------------------------------------------------------
       
   152 //
       
   153 CSplitItutUiMgrBase::TUiState CWesternSplitItutUiStateNonPredict::StateType()
       
   154     {
       
   155     return CSplitItutUiMgrBase::EStateWesternStandby;
       
   156     }
       
   157 
       
   158 // ---------------------------------------------------------------------------
       
   159 // CWesternSplitItutUiStateNonPredict::HandleCommandL
       
   160 // ---------------------------------------------------------------------------
       
   161 //
       
   162 TInt CWesternSplitItutUiStateNonPredict::HandleCommandL(TInt aCmd, TUint8* /*aData*/)
       
   163     {
       
   164     switch (aCmd) 
       
   165         {
       
   166         case ECmdPenInputFingerMatchList:
       
   167             {
       
   168             iOwner->LayoutContext()->UiLayout()->SignalOwner(ESignalEnterSpellMode);
       
   169             return KErrNone;
       
   170             }
       
   171         
       
   172         case ECmdPenInputIsSecretText:
       
   173             {
       
   174             //TUint* data = (TUint*) aData;
       
   175                 {
       
   176                 if (iOwner->DataMgr()->IsChinese())
       
   177                     {
       
   178                     iOwner->LayoutContext()->ShowArrowBtn(EBtnArrowLeft | EBtnArrowRight
       
   179                          | EBtnArrowUp| EBtnArrowDown);
       
   180                     /*CAknFepCtrlRawKeyButton * leftbtn;
       
   181                     CAknFepCtrlRawKeyButton * rightbtn;
       
   182                     CAknFepCtrlRawKeyButton * upbtn;
       
   183                     CAknFepCtrlRawKeyButton * downbtn;
       
   184                     leftbtn = static_cast<CAknFepCtrlRawKeyButton *>(iOwner->LayoutContext()->Control(ECtrlIdArrowLeft));
       
   185                     rightbtn = static_cast<CAknFepCtrlRawKeyButton *>(iOwner->LayoutContext()->Control(ECtrlIdArrowRight));
       
   186                     upbtn = static_cast<CAknFepCtrlRawKeyButton *>(iOwner->LayoutContext()->Control(ECtrlIdArrowUp));
       
   187                     downbtn = static_cast<CAknFepCtrlRawKeyButton *>(iOwner->LayoutContext()->Control(ECtrlIdArrowDown));                                    
       
   188                     if(*data > 0)
       
   189                         {                    
       
   190                         leftbtn->SetDimmed(ETrue);   
       
   191                         rightbtn->SetDimmed(ETrue);   
       
   192                         upbtn->SetDimmed(ETrue);   
       
   193                         downbtn->SetDimmed(ETrue);   
       
   194                         }
       
   195                     else
       
   196                         {
       
   197                         leftbtn->SetDimmed(EFalse);   
       
   198                         rightbtn->SetDimmed(EFalse);   
       
   199                         upbtn->SetDimmed(EFalse);   
       
   200                         downbtn->SetDimmed(EFalse);                           
       
   201                         }*/
       
   202                     }
       
   203                 else
       
   204                     {
       
   205                     iOwner->LayoutContext()->ShowArrowBtn(EBtnArrowLeft | EBtnArrowRight);    
       
   206                     /*CAknFepCtrlRawKeyButton * leftbtn;
       
   207                     CAknFepCtrlRawKeyButton * rightbtn;
       
   208                     leftbtn = static_cast<CAknFepCtrlRawKeyButton *>(iOwner->LayoutContext()->Control(ECtrlIdArrowLeft));
       
   209                     rightbtn = static_cast<CAknFepCtrlRawKeyButton *>(iOwner->LayoutContext()->Control(ECtrlIdArrowRight));
       
   210                     if(*data > 0)
       
   211                         {
       
   212                         leftbtn->SetDimmed(ETrue);   
       
   213                         rightbtn->SetDimmed(ETrue);   
       
   214                         }
       
   215                     else
       
   216                         {
       
   217                         leftbtn->SetDimmed(EFalse);   
       
   218                         rightbtn->SetDimmed(EFalse);   
       
   219                         }*/
       
   220                     }
       
   221                 }
       
   222 
       
   223             return KErrNone;
       
   224             }
       
   225         default:
       
   226             break;
       
   227         }
       
   228 
       
   229     return KErrNotSupported;    
       
   230     }
       
   231 
       
   232 // ---------------------------------------------------------------------------
       
   233 // CWesternSplitItutUiStateNonPredict::HandleCtrlEventL
       
   234 // ---------------------------------------------------------------------------
       
   235 //
       
   236 TBool CWesternSplitItutUiStateNonPredict::HandleCtrlEventL(
       
   237     TInt aEventType, CFepUiBaseCtrl* aCtrl, const TDesC& aEventData)
       
   238     {
       
   239     switch (aEventType)
       
   240         {
       
   241         case EEventRawKeyDownEvent:
       
   242             {
       
   243             const TKeyEvent *key = reinterpret_cast<const TKeyEvent*>(aEventData.Ptr());
       
   244 
       
   245             iConsumeLastKeyDown = EFalse;
       
   246 /*
       
   247             if (key->iScanCode == EStdKeyNkpAsterisk)
       
   248                 {
       
   249                 iConsumeLastKeyDown = ETrue;
       
   250                 iOwner->UiManager()->SetLastRawKeyDown(key->iScanCode, ETrue, aCtrl);
       
   251                 return ETrue;
       
   252                 }
       
   253 */
       
   254             return EFalse;    
       
   255             }
       
   256         case EEventRawKeyUpEvent:
       
   257             {
       
   258             const TKeyEvent *key = reinterpret_cast<const TKeyEvent*>(aEventData.Ptr());
       
   259 /*
       
   260             if (key->iScanCode == EStdKeyNkpAsterisk)
       
   261                 {
       
   262                 if (iConsumeLastKeyDown)
       
   263                     {
       
   264                     iOwner->LayoutContext()->UiLayout()->SignalOwner(ESignalEnterSpellMode);
       
   265                     iOwner->UiManager()->SetLastRawKeyDown(key->iScanCode, EFalse, aCtrl);
       
   266                     return ETrue;
       
   267                     }
       
   268                 }
       
   269 */
       
   270             return EFalse;    
       
   271             }
       
   272         case EEventPointerDownOnNomatch:
       
   273             {
       
   274             iOwner->LayoutContext()->UiLayout()->SignalOwner(ESignalEnterSpellMode);
       
   275             return ETrue;
       
   276             }
       
   277         default:
       
   278             break;
       
   279         }
       
   280 
       
   281     return EFalse;
       
   282     }
       
   283 
       
   284 // End Of File