46     void init();

    46     void init();

    47 

    47 

    48 public:

    48 public:

    49     int mButton;    

    49     int mButton;    

    50     HbFnState mFnState;

    50     HbFnState mFnState;

    53 };

    52 };

    54 

    53 

    55 HbInputPredictionQwertyHandlerPrivate::HbInputPredictionQwertyHandlerPrivate()

    54 HbInputPredictionQwertyHandlerPrivate::HbInputPredictionQwertyHandlerPrivate()

    56 :mButton(0),    

    55 :mButton(0),    

    57     mFnState(HbFnOff),

    56     mFnState(HbFnOff),

    60 {

    58 {

    61 }

    59 }

    62 

    60 

    63 HbInputPredictionQwertyHandlerPrivate::~HbInputPredictionQwertyHandlerPrivate()

    61 HbInputPredictionQwertyHandlerPrivate::~HbInputPredictionQwertyHandlerPrivate()

    64 {

    62 {

    76     if (!focusObject) {

    74     if (!focusObject) {

    77         qDebug("HbVirtualQwerty::virtualButtonClicked : no focused editor widget!");

    75         qDebug("HbVirtualQwerty::virtualButtonClicked : no focused editor widget!");

    78         return false;

    76         return false;

    79     }

    77     }

    80 

    78 

    85 

    79 

    86     int key = event->key();

    80     int key = event->key();

    87     

    81     

    88     bool ret = true;

    82     bool ret = true;

    89     switch(key) {    

    83     switch(key) {    

    95             } else {

    89             } else {

    96                 mFnState = HbFnOff;

    90                 mFnState = HbFnOff;

    97             }

    91             }

    98         break;

    92         break;

    99     case HbInputButton::ButtonKeyCodeShift: {

    93     case HbInputButton::ButtonKeyCodeShift: {

   117             case HbTextCaseAutomatic:

   111             case HbTextCaseAutomatic:

   119                 break;

   113                 break;

   120             default:

   114             default:

   121                 break;

   115                 break;

   122             }

   116             }

   126         }

   120         }

   127         break;

   121         break;

   128     case HbInputButton::ButtonKeyCodeSymbol: { // Ctrl/Chr

   122     case HbInputButton::ButtonKeyCodeSymbol: { // Ctrl/Chr

   129     case HbInputButton::ButtonKeyCodeAlphabet:

   123     case HbInputButton::ButtonKeyCodeAlphabet:

   132         break;

   126         break;

   133     default: {

   130     default: {

   134             HbTextCase currentTextCase = focusObject->editorInterface().textCase();

   131             HbTextCase currentTextCase = focusObject->editorInterface().textCase();

   135             Qt::KeyboardModifiers modifiers = Qt::NoModifier;

   132             Qt::KeyboardModifiers modifiers = Qt::NoModifier;

   136             if (mFnState == HbFnNext) {

   133             if (mFnState == HbFnNext) {

   137                 modifiers |= Qt::AltModifier;

   134                 modifiers |= Qt::AltModifier;

   164 bool HbInputPredictionQwertyHandlerPrivate::buttonPressed(const QKeyEvent *event)

   161 bool HbInputPredictionQwertyHandlerPrivate::buttonPressed(const QKeyEvent *event)

   165 {

   162 {

   166     if (event->isAutoRepeat() && mButton == event->key()) {

   163     if (event->isAutoRepeat() && mButton == event->key()) {

   167         if (mButton == HbInputButton::ButtonKeyCodeSymbol) {

   164         if (mButton == HbInputButton::ButtonKeyCodeSymbol) {

   168             mInputMethod->selectSpecialCharacterTableMode();

   165             mInputMethod->selectSpecialCharacterTableMode();

   172             mButton = 0;        

   166             mButton = 0;        

   173             return true;

   167             return true;

   174         }

   168         }

   175     }

   169     }

   176         

   170         

   198 {

   192 {

   199     Q_D(HbInputPredictionQwertyHandler);

   193     Q_D(HbInputPredictionQwertyHandler);

   200     bool ret = true;

   194     bool ret = true;

   201     switch (action) {

   195     switch (action) {

   202         case HbInputModeActionCancelButtonPress:

   196         case HbInputModeActionCancelButtonPress:

   204             break;

   197             break;

   205         case HbInputModeActionFocusRecieved:

   198         case HbInputModeActionFocusRecieved:

   206             HbInputPredictionHandler::actionHandler(HbInputModeActionSetCandidateList);

   199             HbInputPredictionHandler::actionHandler(HbInputModeActionSetCandidateList);

   207             HbInputPredictionHandler::actionHandler(HbInputModeActionSetKeypad);

   200             HbInputPredictionHandler::actionHandler(HbInputModeActionSetKeypad);

   208             break;

   201             break;

   218             }

   211             }

   219             */

   212             */

   220             // close exactword popup.

   213             // close exactword popup.

   221             d->mInputMethod->closeExactWordPopup();

   214             d->mInputMethod->closeExactWordPopup();

   222             break;

   215             break;

   227     }

   218     }

   228     return ret;

   219     return ret;

   229 }

   220 }

   230 

   221 

   231 /*!

   222 /*!

   249 {

   240 {

   250     Q_D(HbInputPredictionQwertyHandler);

   241     Q_D(HbInputPredictionQwertyHandler);

   251     HbInputModeHandler::commitAndUpdate(string, replaceFrom, replaceLength);

   242     HbInputModeHandler::commitAndUpdate(string, replaceFrom, replaceLength);

   252     d->mInputMethod->closeExactWordPopup();

   243     d->mInputMethod->closeExactWordPopup();

   253     d->mExactPopupLaunched = false;  

   244     d->mExactPopupLaunched = false;  

   255 }

   246 }

   256 

   247 

   257 /*!

   248 /*!

   258     this function deletes one character and updates the engine and editor.

   249     this function deletes one character and updates the engine and editor.

   259 */

   250 */

   320         //can go on with prediction. This is because when we delete a key press

   311         //can go on with prediction. This is because when we delete a key press

   321         //we actually reduce ambiguity in the engine and hence we should have

   312         //we actually reduce ambiguity in the engine and hence we should have

   322         //some word getting predicted as a result to that.

   313         //some word getting predicted as a result to that.

   323         mCanContinuePrediction = true;

   314         mCanContinuePrediction = true;

   324  

   315  

   332         //When there is a deletion of key press, no need to update the candidate list

   323         //When there is a deletion of key press, no need to update the candidate list

   333         //This is because deletion should not cause reprediction.

   324         //This is because deletion should not cause reprediction.

   341                 currentWord.chop(1);

   332                 currentWord.chop(1);

   352             //If Input length greater or equal to one then Append the current word to candidate 

   343             //If Input length greater or equal to one then Append the current word to candidate 

   354         }

   345         }

   355         // update the editor with the new preedit text.

   346         // update the editor with the new preedit text.

   356         updateEditor();

   347         updateEditor();

   357         return;

   348         return;

   358     } else {

   349     } else {