phoneapp/phoneuiqtviewadapter/src/phoneresourceadapter.cpp
changeset 46 bc5a64e5bc3c
parent 45 6b911d05207e
child 50 377c906a8701
child 51 f39ed5e045e0
equal deleted inserted replaced
45:6b911d05207e 46:bc5a64e5bc3c
   204     }
   204     }
   205     
   205     
   206     return translatedActions;
   206     return translatedActions;
   207 }
   207 }
   208 
   208 
   209 QString PhoneResourceAdapter::convertToString(int symbianResourceId) const
   209 QString PhoneResourceAdapter::convertToString(
       
   210         int symbianResourceId, const QString &causeCode) const
   210 {
   211 {
   211     QString ret;
   212     QString ret;
   212     
   213     
   213     switch (symbianResourceId) {
   214     switch (symbianResourceId) {
   214         case R_PHONE_ERROR_CALL_NOT_ALLOWED:
   215         case R_PHONE_ERROR_CALL_NOT_ALLOWED:
   215             {
   216             {
   216             ret = hbTrId("txt_phone_dpopinfo_not_allowed");      
   217             ret = hbTrId("txt_phone_dpopinfo_not_allowed").arg(causeCode);      
   217             }
   218             }
   218             break;
   219             break;
   219             
   220             
   220         case R_ERROR_NOTE_NOT_ALLOWED:
   221         case R_ERROR_NOTE_NOT_ALLOWED:
   221             {
   222             {
   222             ret =  hbTrId("txt_phone_dpopinfo_not_allowed");  
   223             ret =  hbTrId("txt_phone_dpopinfo_not_allowed").arg(causeCode);  
   223             }
   224             }
   224             break;
   225             break;
   225             
   226             
   226         case R_NOTETEXT_INVALID_PHONENUMBER:
   227         case R_NOTETEXT_INVALID_PHONENUMBER:
   227             {
   228             {
   228             ret = hbTrId("txt_phone_info_invalid_phone_number"); 
   229             ret = hbTrId("txt_phone_info_invalid_phone_number").arg(causeCode); 
   229             }
   230             }
   230             break;
   231             break;
   231             
   232             
   232         case R_NOTETEXT_NO_ANSWER:
   233         case R_NOTETEXT_NO_ANSWER:
   233             {
   234             {
   234             ret = hbTrId("txt_phone_info_no_answer"); 
   235             ret = hbTrId("txt_phone_info_no_answer").arg(causeCode); 
   235             }
   236             }
   236             break;
   237             break;
   237         
   238         
   238         case R_PHONE_ERROR_NUMBER_BUSY:
   239         case R_PHONE_ERROR_NUMBER_BUSY:
   239             {
   240             {
   240             ret = hbTrId("txt_phone_info_number_busy"); 
   241             ret = hbTrId("txt_phone_info_number_busy").arg(causeCode);
   241             }
   242             }
   242             break;
   243             break;
   243             
   244             
   244         case R_PHONE_SS_NOTIFICATION_MOCAL_WAITING_TEXT:
   245         case R_PHONE_ERROR_REQUEST_REJECTED:
   245             {
   246             {
   246             ret = hbTrId("txt_phone_other_waiting");
   247             ret = hbTrId("txt_phone_info_request_rejected").arg(causeCode); 
   247             }
   248             }
   248             break;
   249             break;
   249             
   250                 
   250         case R_PHONE_SS_NOTIFICATION_INCAL_INFO_HOLD_TEXT:
   251         case R_PHONE_SS_NOTIFICATION_INCAL_INFO_HOLD_TEXT:
   251             {
   252             {
   252             ret = hbTrId("txt_phone_other_on_hold");
   253             ret = hbTrId("txt_phone_dpopinfo_on_hold");
   253             }
   254             }
   254             break;
   255             break;
   255             
   256             
   256         case R_INCAL_INFO_HOLD_TEXT:
   257         case R_INCAL_INFO_HOLD_TEXT:
   257             {
   258             {
   258             ret = hbTrId("txt_phone_other_on_hold");
   259             ret = hbTrId("txt_phone_dpopinfo_on_hold");
   259             }
   260             }
   260             break;
   261             break;
   261             
   262             
   262         case R_INCAL_REMOTE_ACTIVE_TEXT:
   263         case R_INCAL_REMOTE_ACTIVE_TEXT:
   263             {
   264             {
   264             ret = hbTrId("txt_phone_info_connected");
   265             ret = hbTrId("txt_phone_info_connected");
   265             }
   266             }
   266             break;
   267             break;
   267             
   268             
   268         case R_INCAL_INFO_CONF_HOLD_TEXT:
       
   269             {
       
   270             ret = hbTrId("Conference on hold");
       
   271             }
       
   272             break;
       
   273         case R_PHONE_INCALL_INFO_NO_NETWORK_SUPPORT:
   269         case R_PHONE_INCALL_INFO_NO_NETWORK_SUPPORT:
   274             {
   270             {
   275             ret = hbTrId("txt_phone_info_no_network_support_for_video_call");
   271             ret = hbTrId("txt_phone_info_no_network_support_for_video_call").arg(causeCode);
   276             }
   272             }
   277             break;
   273             break;
   278         case R_PHONE_ERROR_EMERGENCY_CALLS_ONLY:
   274         case R_PHONE_ERROR_EMERGENCY_CALLS_ONLY:
   279             {
   275             {
   280             ret = hbTrId("txt_phone_info_emergency_calls_only");         
   276             ret = hbTrId("txt_phone_info_emergency_calls_only").arg(causeCode);         
   281             }
   277             }
   282             break;
   278             break;
   283         case R_NOTETEXT_NUMBER_NOT_IN_USE:
   279         case R_NOTETEXT_NUMBER_NOT_IN_USE:
   284             {
   280             {
   285             ret = hbTrId("txt_phone_info_number_not_in_use");         
   281             ret = hbTrId("txt_phone_info_number_not_in_use").arg(causeCode);         
   286             }
   282             }
   287             break;
   283             break;
   288         case R_NOTETEXT_NETWORK_BUSY:
   284         case R_NOTETEXT_NETWORK_BUSY:
   289             {
   285             {
   290             ret = hbTrId("txt_phone_info_network_busy");         
   286             ret = hbTrId("txt_phone_info_network_busy").arg(causeCode);         
   291             }
   287             }
   292             break;
   288             break;
   293         case R_NOTETEXT_ERROR_IN_CONNECTION:
   289         case R_NOTETEXT_ERROR_IN_CONNECTION:
   294             {
   290             {
   295             ret = hbTrId("txt_phone_info_error_in_connection");         
   291             ret = hbTrId("txt_phone_info_error_in_connection").arg(causeCode);         
   296             }
   292             }
   297             break;
   293             break;
   298         case R_PHONEUI_ERROR_EMERGENCY_ATTEMPT_FAILED:
   294         case R_PHONEUI_ERROR_EMERGENCY_ATTEMPT_FAILED:
   299             {
   295             {
   300             ret = hbTrId("txt_phone_info_emergency_call_failed");         
   296             ret = hbTrId("txt_phone_info_emergency_call_failed").arg(causeCode);         
   301             }
   297             }
   302             break;
   298             break;
   303         case R_PHONE_SS_NOTIFICATION_INCAL_TRANSFERRED_TEXT:
   299         case R_PHONE_SS_NOTIFICATION_INCAL_TRANSFERRED_TEXT:
   304             {
   300             {
   305             ret = hbTrId("txt_phone_info_transferred");         
   301             ret = hbTrId("txt_phone_info_transferred");         
   306             }
   302             }
   307             break;
   303             break;
   308         case R_PHONE_ERROR_NO_SERVICE:
   304         case R_PHONE_ERROR_NO_SERVICE:
   309             {
   305             {
   310             ret = hbTrId("txt_phone_dpopinfo_no_network_coverage");         
   306             ret = hbTrId("txt_phone_dpopinfo_no_network_coverage").arg(causeCode);         
   311             }
   307             }
   312             break;
   308             break;
   313         case R_NOTETEXT_NUMBER_BARRED:
   309         case R_NOTETEXT_NUMBER_BARRED:
   314             {
   310             {
   315             ret = hbTrId("txt_phone_info_number_barred");
   311             ret = hbTrId("txt_phone_info_number_barred").arg(causeCode);
   316             }
       
   317             break;
       
   318         case R_PHONEUI_NO_VIDEO_NETWORK:
       
   319             {
       
   320             ret = hbTrId("txt_phone_info_video_call_setup_failed");
       
   321             }
   312             }
   322             break;
   313             break;
   323         case R_PHONEUI_VIDEO_CALL_NOT_POSSIBLE:
   314         case R_PHONEUI_VIDEO_CALL_NOT_POSSIBLE:
   324             {
   315             {
   325             ret = hbTrId("txt_phone_info_video_call_didnt_succeed_to_called");
   316             ret = hbTrId("txt_phone_info_video_call_didnt_succeed_to_called").arg(causeCode);
   326             }
   317             }
   327             break;
   318             break;
   328         case R_CALL_INFO_CAUSE_VALUE127:
   319         case R_CALL_INFO_CAUSE_VALUE127:
   329         case R_CALL_INFO_NOT_SUPPORTED:
   320         case R_CALL_INFO_NOT_SUPPORTED:
   330         case R_CALL_INFO_SERVICE_NOT_AVAILABLE:
   321         case R_CALL_INFO_SERVICE_NOT_AVAILABLE:
   331         case R_CALL_INFO_CAUSE_VALUE38:
   322         case R_CALL_INFO_CAUSE_VALUE38:
   332         case R_CALL_INFO_CAUSE_VALUE55:
   323         case R_CALL_INFO_CAUSE_VALUE55:
   333         case R_CALL_INFO_CAUSE_VALUE58:
   324         case R_CALL_INFO_CAUSE_VALUE58:
   334         case R_NOTE_UNABLE_TO_MAKE_VIDEO_CALL_NOT_SUPPORTED_BY_OTHER_PHONE:
   325         case R_NOTE_UNABLE_TO_MAKE_VIDEO_CALL_NOT_SUPPORTED_BY_OTHER_PHONE:
   335             {
   326             {
   336             ret = hbTrId("txt_phone_info_unable_to_make_video_call_not_supp");
   327             ret = hbTrId("txt_phone_info_unable_to_make_video_call_not_supp").arg(causeCode);
   337             }
   328             }
   338             break;
   329             break;
   339         case R_NOTE_PHONE_OUT_OF_3G_COVERAGE:
   330         case R_NOTE_PHONE_OUT_OF_3G_COVERAGE:
   340             {
   331             {
   341             ret = hbTrId("txt_phone_info_phone_switched_off_or_out_of_3g");
   332             ret = hbTrId("txt_phone_info_phone_switched_off_or_out_of_3g").arg(causeCode);
   342             }
   333             }
   343             break;
   334             break;
   344         case R_NOTE_VIDEO_CALL_ONLY_POSSIBLE_UNDER_3G_COVERAGE:
   335         case R_NOTE_VIDEO_CALL_ONLY_POSSIBLE_UNDER_3G_COVERAGE:
   345             {
   336             {
   346             ret = hbTrId("txt_phone_info_videocall_only_possible_under_3g");
   337             ret = hbTrId("txt_phone_info_videocall_only_possible_under_3g").arg(causeCode);
   347             }
   338             }
   348             break;
   339             break;
   349         case R_NOTE_CALLED_NUMBER_HAS_BARRED_INCOMING_CALLS:
   340         case R_NOTE_CALLED_NUMBER_HAS_BARRED_INCOMING_CALLS:
   350             {
   341             {
   351             ret = hbTrId("txt_phone_info_called_number_has_barred_incoming");
   342             ret = hbTrId("txt_phone_info_called_number_has_barred_incoming").arg(causeCode);
   352             }
   343             }
   353             break;
   344             break;
   354         case R_INCAL_REMOTE_CREATE_CONFERENCE_TEXT:
   345         case R_INCAL_REMOTE_CREATE_CONFERENCE_TEXT:
   355             {
   346             {
   356             ret = hbTrId("txt_phone_info_conference_call_active");
   347             ret = hbTrId("txt_phone_info_conference_call_active");
   361             ret = hbTrId("txt_phone_dpopinfo_note_you_have_active_barrings");
   352             ret = hbTrId("txt_phone_dpopinfo_note_you_have_active_barrings");
   362             }
   353             }
   363             break;
   354             break;
   364         case R_CALL_INFO_CAUSE_VALUE16:
   355         case R_CALL_INFO_CAUSE_VALUE16:
   365             {
   356             {
   366             ret = hbTrId("txt_phone_info_call_ended");
   357             ret = hbTrId("txt_phone_info_no_answer").arg(causeCode);
   367             }
   358             }
   368             break;
   359             break;
   369         case R_CALL_INFO_CAUSE_VALUE18:
   360         case R_CALL_INFO_CAUSE_VALUE18:
   370             {
   361             {
   371             ret = hbTrId("txt_phone_info_no_answer");
   362             ret = hbTrId("txt_phone_info_no_answer").arg(causeCode);
   372             }
   363             }
   373             break;
   364             break;
   374         case R_CALL_INFO_CAUSE_VALUE21:
   365         case R_CALL_INFO_CAUSE_VALUE21:
   375             {
   366             {
   376             ret = hbTrId("txt_phone_info_call_rejected");
   367             ret = hbTrId("txt_phone_info_request_rejected");
   377             }
   368             }
   378             break;
   369             break;
   379         case R_CALL_INFO_CAUSE_VALUE22:
   370         case R_CALL_INFO_CAUSE_VALUE22:
   380             {
   371             {
   381             ret = hbTrId("txt_phone_info_number_not_in_use");
   372             ret = hbTrId("txt_phone_info_number_not_in_use").arg(causeCode);
   382             }
   373             }
   383             break;
   374             break;
   384         case R_CALL_INFO_CAUSE_VALUE34:
   375         case R_CALL_INFO_CAUSE_VALUE34:
   385             {
   376             {
   386             ret = hbTrId("txt_phone_info_network_busy");
   377             ret = hbTrId("txt_phone_info_network_busy").arg(causeCode);
   387             }
   378             }
   388             break;
   379             break;
   389         case R_PHONE_ERROR_CALL_NOT_ALLOWED_FDN:
   380         case R_PHONE_ERROR_CALL_NOT_ALLOWED_FDN:
   390             {
   381             {
   391             ret = hbTrId("txt_phone_info_call_not_allowed_fixed_dialling");
   382             ret = hbTrId("txt_phone_info_call_not_allowed_fixed_dialling").arg(causeCode);
   392             }
   383             }
   393             break;
   384             break;
   394         case R_NOTETEXT_DIVERTING_INCOMING_CALL:
   385         case R_NOTETEXT_DIVERTING_INCOMING_CALL:
   395         case R_NOTETEXT_DIVERTING:
   386         case R_NOTETEXT_DIVERTING:
   396             {
   387             {
   402             ret = hbTrId("txt_phone_dpopinfo_note_all_incoming_calls_diver");
   393             ret = hbTrId("txt_phone_dpopinfo_note_all_incoming_calls_diver");
   403             }
   394             }
   404             break;
   395             break;
   405         case R_PHONE_ERROR_CHECK_CLIR:
   396         case R_PHONE_ERROR_CHECK_CLIR:
   406             {
   397             {
   407             ret = hbTrId("txt_phone_info_check_own_number_sending");
   398             ret = hbTrId("txt_phone_info_check_own_number_sending").arg(causeCode);
   408             }
   399             }
   409             break;
   400             break;
   410         case R_PHONE_SS_NOTIFICATION_CLIR_SUPPR_REJECT_TEXT:
   401         case R_PHONE_SS_NOTIFICATION_CLIR_SUPPR_REJECT_TEXT:
   411             {
   402             {
   412             ret = hbTrId("txt_phone_info_could_not_send_own_number");
   403             ret = hbTrId("txt_phone_info_could_not_send_own_number").arg(causeCode);
   413             }
   404             }
   414             break;
   405             break;
   415         case R_NOTE_TEXT_CLIR_CHANGE:
   406         case R_NOTE_TEXT_CLIR_CHANGE:
   416             {
   407             {
   417             ret = hbTrId("txt_phone_info_activate_own_number_sending");
   408             ret = hbTrId("txt_phone_info_activate_own_number_sending").arg(causeCode);
   418             }
   409             }
   419             break;
   410             break;
   420         case R_PHONE_ERROR_CHECK_NETWORK_SERVICES:
   411         case R_PHONE_ERROR_CHECK_NETWORK_SERVICES:
   421             {
   412             {
   422             ret = hbTrId("txt_phone_info_check_network_services");
   413             ret = hbTrId("txt_phone_info_check_network_services").arg(causeCode);
   423             }
   414             }
   424             break;
   415             break;
   425         case R_PHONE_INCALL_INFO_VIDEO_CALL_NOT_ALLOWED_DURING_RESTORE:
   416         case R_PHONE_INCALL_INFO_VIDEO_CALL_NOT_ALLOWED_DURING_RESTORE:
   426             {
   417             {
   427             ret = hbTrId("txt_phone_info_video_call_not_allowed_during_resto");
   418             ret = hbTrId("txt_phone_info_video_call_not_allowed_during_resto").arg(causeCode);
   428             }
   419             }
   429             break;
   420             break;
   430         default:
   421         default:
   431             break;
   422             break;
   432     }
   423     }
   433 
   424 
   434     return ret;
   425     return ret;
   435 }
   426 }
   436 
   427 
   437 QString PhoneResourceAdapter::convertToString(
   428 QString PhoneResourceAdapter::convertToStringWithParam(
   438         int symbianResourceId, const QString &text) const
   429         int symbianResourceId, const QString &text) const
   439 {
   430 {
   440     QString ret;
   431     QString ret;
   441     
   432     
   442     switch (symbianResourceId) {
   433     switch (symbianResourceId) {
   554         case R_PHONEUI_INCALL_DIALER_CBA:
   545         case R_PHONEUI_INCALL_DIALER_CBA:
   555         case R_PHONEUI_CALLHANDLING_INCALL_UNHOLD_CBA:
   546         case R_PHONEUI_CALLHANDLING_INCALL_UNHOLD_CBA:
   556         case R_PHONEUI_CALLHANDLING_INCALL_UNMUTE_CBA:
   547         case R_PHONEUI_CALLHANDLING_INCALL_UNMUTE_CBA:
   557         case R_PHONEUI_CALLHANDLING_INCALL_HANDSET_CBA:
   548         case R_PHONEUI_CALLHANDLING_INCALL_HANDSET_CBA:
   558         case R_PHONEUI_CALLHANDLING_CALLSETUP_EMPTY_DTMFDIALER_CBA:
   549         case R_PHONEUI_CALLHANDLING_CALLSETUP_EMPTY_DTMFDIALER_CBA:
   559             {
   550         case R_PHONEUI_CALLHANDLING_INCALL_BTAA_CBA:
       
   551             {
       
   552             if (m_buttonsCtrl->getButtonFlags(
       
   553                     PhoneUIQtButtonsController::IhfAsPushButton)) {
       
   554                 if (m_buttonsCtrl->getButtonFlags(
       
   555                         PhoneUIQtButtonsController::Mute)) {
       
   556                     ret.append(PhoneAction::ToolBarItem(
       
   557                             PhoneInCallCmdUnmute,true));
       
   558                 } else {
       
   559                     ret.append(PhoneAction::ToolBarItem(
       
   560                             PhoneInCallCmdMute,true));
       
   561                 }
       
   562             } else {
       
   563                 if (m_buttonsCtrl->getButtonFlags(
       
   564                         PhoneUIQtButtonsController::BluetoothAvailable)) {
       
   565                     if (m_buttonsCtrl->getButtonFlags(
       
   566                             PhoneUIQtButtonsController::Btaa)) {
       
   567                         ret.append(PhoneAction::ToolBarItem(
       
   568                                 PhoneInCallCmdHandset,true));
       
   569                     } else {
       
   570                         ret.append(PhoneAction::ToolBarItem(
       
   571                                 PhoneInCallCmdBtHandsfree,true));
       
   572                     }               
       
   573                 } else {
       
   574                     if (!m_buttonsCtrl->getButtonFlags(
       
   575                             PhoneUIQtButtonsController::Ihf)) {
       
   576                         ret.append(PhoneAction::ToolBarItem(
       
   577                                 PhoneInCallCmdActivateIhf,true));
       
   578                     } else {
       
   579                         ret.append(PhoneAction::ToolBarItem(
       
   580                                 PhoneInCallCmdDeactivateIhf,true));
       
   581                     }
       
   582                 }
       
   583             }
       
   584             
       
   585             if (!m_buttonsCtrl->getButtonFlags(
       
   586                     PhoneUIQtButtonsController::MultiCall)) {
       
   587                 bool outgoing(m_buttonsCtrl->getButtonFlags(
       
   588                         PhoneUIQtButtonsController::Outgoing));
       
   589                 if (m_buttonsCtrl->getButtonFlags(
       
   590                         PhoneUIQtButtonsController::Hold)) {
       
   591                     ret.append(PhoneAction::ToolBarItem(
       
   592                             PhoneInCallCmdUnhold,!outgoing));
       
   593                 } else {
       
   594                     ret.append(PhoneAction::ToolBarItem(
       
   595                             PhoneInCallCmdHold,!outgoing));
       
   596                 }
       
   597                          
       
   598                 ret.append(PhoneAction::ToolBarItem(
       
   599                         PhoneInCallCmdOpenContacts,true));
       
   600             } else {
       
   601                 bool outgoing(m_buttonsCtrl->getButtonFlags(
       
   602                         PhoneUIQtButtonsController::Outgoing));
       
   603                 bool disableJoin(outgoing ? true : 
       
   604                     m_buttonsCtrl->getButtonFlags(
       
   605                             PhoneUIQtButtonsController::DisableJoin));
       
   606                 
       
   607                 ret.append(PhoneAction::ToolBarItem(
       
   608                         PhoneInCallCmdSwap,!outgoing));
       
   609                 
       
   610                 if (m_buttonsCtrl->getButtonFlags(
       
   611                         PhoneUIQtButtonsController::Conference)) {
       
   612                     ret.append(PhoneAction::ToolBarItem(
       
   613                             PhoneInCallCmdJoinToConference,!disableJoin));
       
   614                 } else {
       
   615                     ret.append(PhoneAction::ToolBarItem(
       
   616                             PhoneInCallCmdCreateConference,!disableJoin));
       
   617                 }
       
   618             }
       
   619             
       
   620             ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdOpenDialer,true)); 
       
   621             }
       
   622             break;
       
   623             
       
   624         case R_PHONEUI_CALLHANDLING_EMERGENCY_CBA:
       
   625             {
       
   626             
   560             if (!m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::Ihf))
   627             if (!m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::Ihf))
   561                 {
   628                 {
   562                 ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdActivateIhf,true));
   629                 ret.append(PhoneAction::ToolBarItem(
       
   630                         PhoneInCallCmdActivateIhf,true));
   563                 }
   631                 }
   564             else
   632             else
   565                 {
   633                 {
   566                 ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdDeactivateIhf,true));
   634                 ret.append(PhoneAction::ToolBarItem(
   567                 }
   635                         PhoneInCallCmdDeactivateIhf,true));
   568             
       
   569             if (!m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::MultiCall)) {
       
   570                 bool outgoing(m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::Outgoing));
       
   571                 if (m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::Hold))
       
   572                     {
       
   573                     ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdUnhold,!outgoing));
       
   574                     }
       
   575                 else
       
   576                     {
       
   577                     ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdHold,!outgoing));
       
   578                     }
       
   579                          
       
   580                 ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdOpenContacts,true));
       
   581             } else {
       
   582                 bool outgoing(m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::Outgoing));
       
   583                 bool disableJoin(outgoing ? true : m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::DisableJoin));
       
   584                 
       
   585                 ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdSwap,!outgoing));
       
   586                 if (m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::Conference)) {
       
   587                     ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdJoinToConference,!disableJoin));
       
   588                 } else {
       
   589                     ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdCreateConference,!disableJoin));
       
   590                 }
       
   591             }
       
   592             
       
   593             ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdOpenDialer,true)); 
       
   594             }
       
   595             break;
       
   596             
       
   597         case R_PHONEUI_CALLHANDLING_EMERGENCY_CBA:
       
   598             {
       
   599             
       
   600             if (!m_buttonsCtrl->getButtonFlags(PhoneUIQtButtonsController::Ihf))
       
   601                 {
       
   602                 ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdActivateIhf,true));
       
   603                 }
       
   604             else
       
   605                 {
       
   606                 ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdDeactivateIhf,true));
       
   607                 }                 
   636                 }                 
   608             }
   637             }
   609 			
   638 			
   610             ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdOpenDialer,true));
   639             ret.append(PhoneAction::ToolBarItem(PhoneInCallCmdOpenDialer,true));
   611             break;
   640             break;