140 { |
139 { |
141 __LOGMETHODSTARTEND( EPhoneControl, |
140 __LOGMETHODSTARTEND( EPhoneControl, |
142 "CPhoneKeyEventForwarder::OfferKeyEventL"); |
141 "CPhoneKeyEventForwarder::OfferKeyEventL"); |
143 |
142 |
144 TKeyResponse ret( EKeyWasNotConsumed ); |
143 TKeyResponse ret( EKeyWasNotConsumed ); |
145 TKeyEvent keyEvent = aKeyEvent; |
|
146 |
144 |
147 ret = OfferKeyEventBeforeControlStackL( aKeyEvent, aType ); |
145 ret = OfferKeyEventBeforeControlStackL( aKeyEvent, aType ); |
148 |
146 |
149 // Convert event. Use already converted iKeyPressedDown. |
147 if ( !aKeyEvent.iRepeats ) |
150 // Do not convert other than DTMF tones |
148 { |
151 if( CPhoneKeys::IsDtmfTone( aKeyEvent, aType ) ) |
149 // Convert event. Use already converted iKeyPressedDown. |
152 { |
150 TKeyEvent keyEvent = aKeyEvent; |
153 keyEvent.iCode = iKeyPressedDown; |
151 keyEvent.iCode = iKeyPressedDown; |
154 } |
152 |
155 |
|
156 if ( !keyEvent.iRepeats ) |
|
157 { |
|
158 // Start and stop dtmf |
153 // Start and stop dtmf |
159 iStateMachine->State()->HandleDtmfKeyToneL( keyEvent, aType ); |
154 iStateMachine->State()->HandleDtmfKeyToneL( keyEvent, aType ); |
160 if( aType != EEventKeyUp && |
155 // Open number entry view if any allowed character key |
161 ( CPhoneKeys::IsNumericKey( keyEvent, aType ) || |
156 // is pressed on homescreen or in-call ui |
162 IsAlphaNumericKey( keyEvent ) ) |
157 if ( aType != EEventKeyUp && IsKeyAllowed( keyEvent ) ) |
163 ) |
|
164 { |
158 { |
165 // Do not open number entry with up key |
159 // Do not open number entry with up key |
166 iStateMachine->State()->HandleCreateNumberEntryL( keyEvent, aType ); |
160 iStateMachine->State()->HandleCreateNumberEntryL( keyEvent, aType ); |
167 } |
161 } |
168 } |
162 } |
200 // Create invisible control. |
194 // Create invisible control. |
201 CreateWindowL(); |
195 CreateWindowL(); |
202 MakeVisible( EFalse ); |
196 MakeVisible( EFalse ); |
203 SetRect( aRect ); |
197 SetRect( aRect ); |
204 |
198 |
205 CEikonEnv* env = static_cast<CEikonEnv*>(ControlEnv()); |
199 if ( iEikonEnv ) |
206 if( env ) |
200 { |
207 { |
201 iEikonEnv->EikAppUi()->AddToStackL( |
208 env->EikAppUi()->AddToStackL( |
|
209 this, |
202 this, |
210 ECoeStackPriorityEnvironmentFilter, |
203 ECoeStackPriorityEnvironmentFilter, |
211 ECoeStackFlagRefusesFocus ); |
204 ECoeStackFlagRefusesFocus ); |
212 } |
205 } |
213 |
206 |
214 // Create the long press key event timer |
207 // Create the long press key event timer |
215 iLongPressKeyEventTimer = CPhoneTimer::NewL(); |
208 iLongPressKeyEventTimer = CPhoneTimer::NewL(); |
216 |
209 |
217 // Create qwerty mode handler |
210 // Create qwerty mode handler |
218 iQwertyHandler = CPhoneQwertyHandler::NewL(); |
211 iQwertyHandler = CPhoneQwertyHandler::NewL(); |
219 |
212 |
220 TPhoneCmdParamPointer ptrParam; |
213 TPhoneCmdParamPointer ptrParam; |
221 iViewCommandHandle->ExecuteCommand( EPhoneViewGetQwertyModeObserver, &ptrParam ); |
214 iViewCommandHandle->ExecuteCommand( EPhoneViewGetQwertyModeObserver, &ptrParam ); |
222 CDialer* qwertyObserver = |
215 CDialer* qwertyObserver = |
223 static_cast<CDialer*>( ptrParam.Pointer() ); |
216 static_cast<CDialer*>( ptrParam.Pointer() ); |
224 |
217 |
225 iQwertyHandler->AddQwertyModeObserverL( *qwertyObserver ); |
218 iQwertyHandler->AddQwertyModeObserverL( *qwertyObserver ); |
226 |
|
227 } |
219 } |
228 |
220 |
229 // ----------------------------------------------------------------------------- |
221 // ----------------------------------------------------------------------------- |
230 // CPhoneKeyEventForwarder::IsAlphaNumericKey |
222 // CPhoneKeyEventForwarder::IsAlphaNumericKey |
231 // ----------------------------------------------------------------------------- |
223 // ----------------------------------------------------------------------------- |
232 // |
224 // |
233 TBool CPhoneKeyEventForwarder::IsAlphaNumericKey( const TKeyEvent& aKeyEvent ) |
225 TBool CPhoneKeyEventForwarder::IsKeyAllowed( const TKeyEvent& aKeyEvent ) |
234 { |
226 { |
235 __LOGMETHODSTARTEND( EPhoneControl, |
227 __LOGMETHODSTARTEND( EPhoneControl, |
236 "CPhoneKeyEventForwarder::IsAlphaNumericKey"); |
228 "CPhoneKeyEventForwarder::IsAlphaNumericKey"); |
237 |
229 |
238 TBool alphaNumeric = |
230 TKeyEvent keyEvent( aKeyEvent ); |
239 iStateMachine->State()->IsAlphanumericSupportedAndCharInput( aKeyEvent ); |
231 |
240 |
232 // Check keyboard mode |
241 return alphaNumeric; |
233 TBool isModeNumeric = iViewCommandHandle->HandleCommandL( |
|
234 EPhoneViewIsNumberEntryNumericMode ) == EPhoneViewResponseSuccess; |
|
235 |
|
236 // Check if key is a numeric key |
|
237 TBool isNumeric = CPhoneKeys::IsNumericKey( keyEvent, EEventKey ); |
|
238 |
|
239 // Check if key is alpha numeric key and alphabet input is allowed |
|
240 TBool isAllowedAlphaNumeric = |
|
241 iStateMachine->State()->IsAlphanumericSupportedAndCharInput( keyEvent ); |
|
242 |
|
243 return ( ( isModeNumeric && isNumeric ) || |
|
244 ( !isModeNumeric && isAllowedAlphaNumeric ) ); |
242 } |
245 } |
243 |
246 |
244 // ----------------------------------------------------------------------------- |
247 // ----------------------------------------------------------------------------- |
245 // CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar |
248 // CPhoneKeyEventForwarder::ConvertHalfQwertySpecialChar |
246 // ----------------------------------------------------------------------------- |
249 // ----------------------------------------------------------------------------- |
283 |
286 |
284 return ret; |
287 return ret; |
285 } |
288 } |
286 |
289 |
287 // ----------------------------------------------------------------------------- |
290 // ----------------------------------------------------------------------------- |
|
291 // CPhoneKeyEventForwarder::IsKeySimulatedByTouchDialer |
|
292 // |
|
293 // ----------------------------------------------------------------------------- |
|
294 // |
|
295 TBool CPhoneKeyEventForwarder::IsKeySimulatedByTouchDialer( |
|
296 const TKeyEvent& aKeyEvent ) const |
|
297 { |
|
298 return ( ( aKeyEvent.iModifiers & EModifierNumLock ) && |
|
299 ( aKeyEvent.iModifiers & EModifierKeypad ) ); |
|
300 } |
|
301 |
|
302 // ----------------------------------------------------------------------------- |
288 // CPhoneKeyEventForwarder::HandleTouchDialerKeyEventL |
303 // CPhoneKeyEventForwarder::HandleTouchDialerKeyEventL |
289 // |
304 // Handle EEventKey type of event from touch dialer |
290 // ----------------------------------------------------------------------------- |
305 // ----------------------------------------------------------------------------- |
291 // |
306 // |
292 void CPhoneKeyEventForwarder::HandleTouchDialerKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType ) |
307 void CPhoneKeyEventForwarder::HandleTouchDialerKeyEventL( const TKeyEvent& aKeyEvent ) |
293 { |
308 { |
294 TBool multitap = aKeyEvent.iScanCode == EStdKeyNkpAsterisk && |
309 TBool multitap = aKeyEvent.iScanCode == EStdKeyNkpAsterisk && |
295 iPreviousScanCode == EStdKeyNkpAsterisk && |
310 iPreviousScanCode == EStdKeyNkpAsterisk && |
296 iKeyPressTime.MicroSecondsFrom( iPreviousKeyPressTime ) < KMultitapDelay; |
311 iKeyPressTime.MicroSecondsFrom( iPreviousKeyPressTime ) < KMultitapDelay; |
297 |
312 |
298 if ( multitap ) |
313 if ( multitap ) |
299 { |
314 { |
300 if ( aType == EEventKeyDown ) |
315 // Update multitap index |
301 { |
316 iMultitapIndex = ( iMultitapIndex + 1 ) % KAsteriskMultitapCharacters().Length(); |
302 // Update multitap index |
317 |
303 iMultitapIndex = ( iMultitapIndex + 1 ) % KAsteriskMultitapCharacters().Length(); |
318 // Delete the previously entered character by simulating a backspace character. |
304 |
319 TKeyEvent backSpaceEvent; |
305 // Delete the previously entered character by simulating a backspace character. |
320 backSpaceEvent.iModifiers = 0; |
306 TKeyEvent backSpaceEvent; |
321 backSpaceEvent.iRepeats = 0; |
307 backSpaceEvent.iModifiers = 0; |
322 backSpaceEvent.iCode = EKeyBackspace; |
308 backSpaceEvent.iRepeats = 0; |
323 backSpaceEvent.iScanCode = EStdKeyBackspace; |
309 backSpaceEvent.iCode = EKeyBackspace; |
324 iStateMachine->State()->HandleKeyEventL( backSpaceEvent, EEventKey ); |
310 backSpaceEvent.iScanCode = EStdKeyBackspace; |
|
311 iStateMachine->State()->HandleKeyEventL( backSpaceEvent, EEventKey ); |
|
312 } |
|
313 |
325 |
314 TKeyEvent keyEvent( aKeyEvent ); |
326 TKeyEvent keyEvent( aKeyEvent ); |
315 |
327 |
316 // Modify the key event to contain the next character on multitap list. |
328 // Modify the key event to contain the next character on multitap list. |
317 keyEvent.iCode = ( TInt ) KAsteriskMultitapCharacters()[ iMultitapIndex ]; |
329 keyEvent.iCode = ( TInt ) KAsteriskMultitapCharacters()[ iMultitapIndex ]; |
318 |
330 |
319 // Send character to number entry. |
331 // Send character to number entry. |
320 iStateMachine->State()->HandleKeyEventL( keyEvent, aType ); |
332 iStateMachine->State()->HandleKeyEventL( keyEvent, EEventKey ); |
321 } |
333 } |
322 |
|
323 else |
334 else |
324 { |
335 { |
325 iMultitapIndex = 0; |
336 iMultitapIndex = 0; |
326 iStateMachine->State()->HandleKeyEventL( aKeyEvent, aType ); |
337 iStateMachine->State()->HandleKeyEventL( aKeyEvent, EEventKey ); |
327 } |
|
328 |
|
329 if ( aType == EEventKeyUp ) |
|
330 { |
|
331 iPreviousScanCode = aKeyEvent.iScanCode; |
|
332 } |
338 } |
333 } |
339 } |
334 |
340 |
335 // ----------------------------------------------------------------------------- |
341 // ----------------------------------------------------------------------------- |
336 // CPhoneKeyEventForwarder::OfferKeyEventBeforeControlStackL |
342 // CPhoneKeyEventForwarder::OfferKeyEventBeforeControlStackL |
365 response = HandleEventKeyUpBeforeControlStackL( aKeyEvent ); |
371 response = HandleEventKeyUpBeforeControlStackL( aKeyEvent ); |
366 break; |
372 break; |
367 default: |
373 default: |
368 break; |
374 break; |
369 } |
375 } |
370 |
376 |
371 // Check if keyEvent is simulated by Dialer. |
377 return response; |
372 const TBool simulatedByDialer = |
378 } |
373 ( ( aKeyEvent.iModifiers & ( EModifierNumLock | EModifierKeypad ) ) |
379 |
374 == ( EModifierNumLock | EModifierKeypad ) ); |
380 |
375 |
381 // ----------------------------------------------------------------------------- |
376 if( simulatedByDialer ) |
382 // CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL |
377 { |
383 // Let phone handle keys if no one has done it already |
378 HandleTouchDialerKeyEventL( aKeyEvent, aType ); |
384 // ----------------------------------------------------------------------------- |
|
385 // |
|
386 TKeyResponse CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL( |
|
387 const TKeyEvent& aKeyEvent, |
|
388 TEventCode aType ) |
|
389 { |
|
390 __LOGMETHODSTARTEND( EPhoneControl, |
|
391 "CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL"); |
|
392 |
|
393 // Send key to editor |
|
394 iStateMachine->State()->HandleKeyEventL( aKeyEvent, aType ); |
|
395 |
|
396 if ( EEventKeyUp == aType && EKeyNull != iKeyPressedDown ) |
|
397 { |
|
398 // Handle short key press |
|
399 iStateMachine->State()->HandleKeyMessageL( |
|
400 MPhoneKeyEvents::EPhoneKeyShortPress, |
|
401 TKeyCode( iKeyPressedDown ) ); |
|
402 |
|
403 // Reset key code |
|
404 iScanCode = EStdKeyNull; |
|
405 iKeyPressedDown = EKeyNull; |
|
406 } |
|
407 |
|
408 return EKeyWasNotConsumed; |
|
409 } |
|
410 |
|
411 // ----------------------------------------------------------- |
|
412 // CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL |
|
413 // ----------------------------------------------------------- |
|
414 // |
|
415 TKeyResponse CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL( |
|
416 const TKeyEvent& aKeyEvent ) |
|
417 { |
|
418 __LOGMETHODSTARTEND( EPhoneControl, |
|
419 "CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL"); |
|
420 |
|
421 // Convert key code |
|
422 ConvertKeyCode( iKeyPressedDown, aKeyEvent ); |
|
423 // Save key scan code |
|
424 iScanCode = aKeyEvent.iScanCode; |
|
425 |
|
426 // Store the previous keypress time. |
|
427 iPreviousKeyPressTime = iKeyPressTime; |
|
428 |
|
429 // Start the key press timer |
|
430 iKeyPressTime.UniversalTime(); |
|
431 |
|
432 // Cancel the long press key event timer, if it is active |
|
433 if ( iLongPressKeyEventTimer->IsActive() ) |
|
434 { |
|
435 iLongPressKeyEventTimer->CancelTimer(); |
|
436 } |
|
437 |
|
438 // Re-start the timer |
|
439 iLongPressKeyEventTimer->After( |
|
440 KPhoneLongPressKeyEventDuration, |
|
441 TCallBack( DoHandleLongPressKeyEventCallbackL, |
|
442 this ) ); |
|
443 |
|
444 return ( EKeyWasNotConsumed ); |
|
445 } |
|
446 |
|
447 // ----------------------------------------------------------- |
|
448 // CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL |
|
449 // Both short key press event (iRepeats == 0) and |
|
450 // long key press event (iRepeats == 1) are handled here |
|
451 // ----------------------------------------------------------- |
|
452 // |
|
453 TKeyResponse CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL( |
|
454 const TKeyEvent& aKeyEvent ) |
|
455 { |
|
456 __LOGMETHODSTARTEND( EPhoneControl, |
|
457 "CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL"); |
|
458 |
|
459 TKeyResponse response( EKeyWasNotConsumed ); |
|
460 TKeyEvent keyEvent( aKeyEvent ); |
|
461 |
|
462 // Special handling for virtual dialer keys events |
|
463 const TBool simulatedByDialer = IsKeySimulatedByTouchDialer( keyEvent ); |
|
464 if ( simulatedByDialer ) |
|
465 { |
|
466 // feed the event directly to number entry |
|
467 HandleTouchDialerKeyEventL( keyEvent ); |
379 response = EKeyWasConsumed; |
468 response = EKeyWasConsumed; |
380 } |
469 } |
381 |
|
382 else |
470 else |
383 { |
471 { |
384 // If not simulated by dialer, multitap related fields are reset. |
472 // If not simulated by dialer, multitap related fields are reset. |
385 // Any key event not originating from dialer interrupts multitap |
473 // Any key event not originating from dialer interrupts multitap |
386 // behaviour. |
474 // behaviour. |
387 iMultitapIndex = 0; |
475 iMultitapIndex = 0; |
388 iPreviousScanCode = 0; |
476 iPreviousScanCode = 0; |
389 } |
477 } |
390 |
478 |
391 return response; |
479 // Special handling for QWERTY numeric mode key events |
392 } |
480 if ( response == EKeyWasNotConsumed ) |
393 |
481 { |
394 |
482 // FEP treats numeric QWERTY mode of Phone editor as a special case where most |
395 // ----------------------------------------------------------------------------- |
483 // key events flow through directly to the Phone app (but some don't). |
396 // CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL |
484 // To ensure consistent handling of numeric mode keys and QWERTY modifiers, |
397 // Let phone handle keys if no one has done it already |
485 // handle those keys manually before FEP has a chance to mess things up. |
398 // ----------------------------------------------------------------------------- |
486 TBool numericMode = iViewCommandHandle->HandleCommandL( |
399 // |
487 EPhoneViewIsNumberEntryNumericMode ) == EPhoneViewResponseSuccess; |
400 TKeyResponse CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL( |
488 |
401 const TKeyEvent& aKeyEvent, |
489 if ( iQwertyHandler->IsQwertyInput() && numericMode ) |
402 TEventCode aType ) |
490 { |
403 { |
491 iQwertyHandler->ConvertToNumeric( keyEvent ); |
404 __LOGMETHODSTARTEND( EPhoneControl, |
492 // Send key to editor unless this is a repeat event for dtmf character |
405 "CPhoneKeyEventForwarder::OfferKeyEventAfterControlStackL"); |
493 if ( aKeyEvent.iRepeats == 0 || |
406 |
494 !CPhoneKeys::IsDtmfTone( keyEvent, EEventKey ) ) |
407 // Send key to editor |
495 { |
408 iStateMachine->State()->HandleKeyEventL( aKeyEvent, aType ); |
496 iStateMachine->State()->HandleKeyEventL( keyEvent, EEventKey ); |
409 |
497 } |
410 if( EEventKeyUp == aType |
498 response = EKeyWasConsumed; |
411 && EKeyNull != iKeyPressedDown ) |
499 } |
412 { |
500 } |
413 // Handle short key press |
501 |
414 iStateMachine->State()->HandleKeyMessageL( |
502 // Prevent repeats of DTMF keys anyway |
415 MPhoneKeyEvents::EPhoneKeyShortPress, |
503 if ( response == EKeyWasNotConsumed ) |
416 TKeyCode( iKeyPressedDown ) ); |
504 { |
417 |
505 // Convert event. |
418 // Reset key code |
506 keyEvent.iCode = iKeyPressedDown; |
419 iScanCode = EStdKeyNull; |
507 if ( aKeyEvent.iRepeats > 0 && |
420 iKeyPressedDown = EKeyNull; |
508 aKeyEvent.iCode != EKeyF18 && // EKeyF18 is used for AknCCPU support |
421 } |
509 CPhoneKeys::IsDtmfTone( keyEvent, EEventKey ) ) |
422 |
510 { |
423 return EKeyWasNotConsumed; |
511 // Do not repeat dtmf characters |
424 } |
512 response = EKeyWasConsumed; |
425 |
513 } |
426 // ----------------------------------------------------------- |
|
427 // CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL |
|
428 // ----------------------------------------------------------- |
|
429 // |
|
430 TKeyResponse CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL( |
|
431 const TKeyEvent& aKeyEvent ) |
|
432 { |
|
433 __LOGMETHODSTARTEND( EPhoneControl, |
|
434 "CPhoneKeyEventForwarder::HandleEventKeyDownBeforeControlStackL"); |
|
435 |
|
436 // Convert key code |
|
437 ConvertKeyCode( iKeyPressedDown, aKeyEvent ); |
|
438 // Save key scan code |
|
439 iScanCode = aKeyEvent.iScanCode; |
|
440 |
|
441 // Store the previous keypress time. |
|
442 iPreviousKeyPressTime = iKeyPressTime; |
|
443 |
|
444 // Start the key press timer |
|
445 iKeyPressTime.UniversalTime(); |
|
446 |
|
447 // Cancel the long press key event timer, if it is active |
|
448 if ( iLongPressKeyEventTimer->IsActive() ) |
|
449 { |
|
450 iLongPressKeyEventTimer->CancelTimer(); |
|
451 } |
|
452 |
|
453 // Re-start the timer |
|
454 iLongPressKeyEventTimer->After( |
|
455 KPhoneLongPressKeyEventDuration, |
|
456 TCallBack( DoHandleLongPressKeyEventCallbackL, |
|
457 this ) ); |
|
458 |
|
459 return ( EKeyWasNotConsumed ); |
|
460 } |
|
461 |
|
462 // ----------------------------------------------------------- |
|
463 // CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL |
|
464 // Both short key press event (iRepeats == 0) and |
|
465 // long key press event (iRepeats == 1) are handled here |
|
466 // ----------------------------------------------------------- |
|
467 // |
|
468 TKeyResponse CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL( |
|
469 const TKeyEvent& aKeyEvent ) |
|
470 { |
|
471 __LOGMETHODSTARTEND( EPhoneControl, |
|
472 "CPhoneKeyEventForwarder::HandleEventKeyBeforeControlStackL"); |
|
473 |
|
474 TKeyResponse response( EKeyWasNotConsumed ); |
|
475 |
|
476 // Convert event. |
|
477 TKeyEvent keyEvent = aKeyEvent; |
|
478 keyEvent.iCode = iKeyPressedDown; |
|
479 |
|
480 if( aKeyEvent.iRepeats > 0 && |
|
481 CPhoneKeys::IsDtmfTone( keyEvent, EEventKey ) ) |
|
482 { |
|
483 // Do not repeat dtmf characters |
|
484 response = EKeyWasConsumed; |
|
485 } |
514 } |
486 |
515 |
487 return response; |
516 return response; |
488 } |
517 } |
489 |
518 |
600 // to iCode conversion hasn't been handled by CAknAppUi::GetAliasKeyCodeL |
632 // to iCode conversion hasn't been handled by CAknAppUi::GetAliasKeyCodeL |
601 __PHONELOG1( EBasic, EPhoneControl, |
633 __PHONELOG1( EBasic, EPhoneControl, |
602 "CPhoneKeyEventHandler::ConvertKeyCode scan code (%d)", |
634 "CPhoneKeyEventHandler::ConvertKeyCode scan code (%d)", |
603 aKeyEvent.iScanCode ); |
635 aKeyEvent.iScanCode ); |
604 |
636 |
605 if( !ConvertHalfQwertySpecialChar( aCode, aKeyEvent ) ) |
637 if ( !ConvertHalfQwertySpecialChar( aCode, aKeyEvent ) ) |
606 { |
638 { |
607 switch ( aKeyEvent.iScanCode ) |
639 TBool numMode = iViewCommandHandle->HandleCommandL( |
|
640 EPhoneViewIsNumberEntryNumericMode ) == EPhoneViewResponseSuccess; |
|
641 TBool simulatedByDialer = IsKeySimulatedByTouchDialer( aKeyEvent ); |
|
642 |
|
643 if ( iQwertyHandler->IsQwertyInput() && numMode && !simulatedByDialer ) |
608 { |
644 { |
609 case EStdKeyEnter: |
645 TUint numCode = iQwertyHandler->NumericKeyCode( aKeyEvent ); |
610 aCode = EKeyEnter; |
646 if ( numCode ) |
611 break; |
647 { |
612 case EStdKeyYes: |
648 aCode = numCode; |
613 aCode = EKeyYes; |
649 } |
614 break; |
650 else |
615 case EStdKeyNo: |
651 { |
616 aCode = EKeyNo; |
652 aCode = aKeyEvent.iScanCode; |
617 break; |
653 } |
618 case EStdKeyDeviceF: |
654 } |
619 aCode = EKeyDeviceF; // EStdKeyDeviceF mapping for unlock switch. |
655 else |
620 break; |
656 { |
621 case EStdKeyHash: |
657 switch ( aKeyEvent.iScanCode ) |
622 aCode = KPhoneDtmfHashCharacter; |
658 { |
623 break; |
659 case EStdKeyEnter: |
624 case EStdKeyNkpAsterisk: |
660 aCode = EKeyEnter; |
625 aCode = KPhoneDtmfStarCharacter; |
661 break; |
626 break; |
662 case EStdKeyYes: |
627 case EStdKeyApplication0: |
663 aCode = EKeyYes; |
628 aCode = EKeyApplication0; |
664 break; |
629 break; |
665 case EStdKeyNo: |
630 |
666 aCode = EKeyNo; |
631 default: |
667 break; |
632 aCode = aKeyEvent.iScanCode; // Use default code |
668 case EStdKeyDeviceF: |
633 break; |
669 aCode = EKeyDeviceF; // EStdKeyDeviceF mapping for unlock switch. |
|
670 break; |
|
671 case EStdKeyHash: |
|
672 aCode = KPhoneDtmfHashCharacter; |
|
673 break; |
|
674 case EStdKeyNkpAsterisk: |
|
675 aCode = KPhoneDtmfStarCharacter; |
|
676 break; |
|
677 case EStdKeyApplication0: |
|
678 aCode = EKeyApplication0; |
|
679 break; |
|
680 default: |
|
681 aCode = aKeyEvent.iScanCode; // Use default code |
|
682 break; |
|
683 } |
634 } |
684 } |
635 } |
685 } |
636 |
686 |
637 __PHONELOG1( EBasic, EPhoneControl, |
687 __PHONELOG1( EBasic, EPhoneControl, |
638 "CPhoneKeyEventHandler::ConvertKeyCode aCode (%d)", aCode ); |
688 "CPhoneKeyEventHandler::ConvertKeyCode aCode (%d)", aCode ); |