diff -r 000000000000 -r 2f259fa3e83a commonuis/CommonUi/src/FindItemMenu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonuis/CommonUi/src/FindItemMenu.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,1841 @@ +/* +* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + +// INCLUDE FILES +#include // for CEikMenuPane +#include // BaflUtils +#include // CEikonEnv +#include "finditemmenu.h" +#include +#include "finditemdialogpanic.h" +#include +#include + +#include + +#include // for CSendAppUi +#include // for CMessageData + +#include // Phonenumber parser +#include // Mtm uids + +#include // KFavouritesMaxUrl +#include // for CBookmarkItem + +#include + +#include // RApaLsSession for WMLBrowser launch +#include + +#ifndef RD_VIRTUAL_PHONEBOOK +#include // Phonebook Engine +#include // Phonebook view dll resource loader +#include // for PbkDataSaveAppUi +#include // Phonebook field types +#else // RD_VIRTUAL_PHONEBOOK +#include // CAiwServiceHandler +#include // AiwContactAssign +#endif // !RD_VIRTUAL_PHONEBOOK + +#include "finditem.hrh" +#include +#include + +// add to gallery related +#include + +#include + +#include +#include + +#include +#include + +// Callback query +#include +#include +#include + +#include "FindItemVoIPExtension.h" + +#include "FindItemMenuWrapper.h" +#include // AknContextPane + +#include // CClipboard + +#include "commonuimpengineapiloader.h" + +// LOCAL CONSTANTS AND MACROS + +// Resource files +_LIT( KResFileName, "z:\\resource\\finditemmenu.rsc" ); +_LIT( KDialogResourceName, "z:\\resource\\finditemui.rsc" ); +_LIT( KCommonUiMPEngineApiLoaderName, "z:\\sys\\bin\\commonuimpengineapiloader.dll" ); + +enum TFindUIAddCNList //handling popup indeces, update there if order of + // query items changes + { + EFindUISenderNumber = 0, + EFindUICallbackNumber = 1 + }; + + +_LIT( KRtspUrlAddress, "rtsp://" ); + +const TInt KMaxMenuTextLength = 40; + +// Maximum length of Browser bookmark +const TInt KMaxBookmarkNameLength = 50; + +// Entry point for dynamically loaded dlls. +const TInt KMPEngineApiDllEntryPoint = 1; + +// TYPE DEFINITIONS +typedef TAny* (*MPEngineApiL)(); + + +// ============================= MEMBER FUNCTIONS ============================== +// ----------------------------------------------------------------------------- +// CFindItemMenu::CFindItemMenu +// C++ default constructor. +// ----------------------------------------------------------------------------- +// +CFindItemMenu::CFindItemMenu() : + iCoeEnv( CCoeEnv::Static() ), + iResLoader( *iCoeEnv ), + iSenderDescType( CItemFinder::EPhoneNumber ), + iSenderHighlighted( EFalse ) +#ifdef RD_VOIP_REL_2_2 + ,iMenuItemFlags( NULL ) // all menu items allowed +#endif // RD_VOIP_REL_2_2 + { + } + +// ----------------------------------------------------------------------------- +// CFindItemMenu::ConstructL +// Second-phase constructor +// ----------------------------------------------------------------------------- +// +void CFindItemMenu::ConstructL( const TInt aCommandId ) + { + iFindItemCommandId = aCommandId; + iFindItemMenuItemAdded = EFalse; + + iDialData = CAiwDialDataExt::NewL(); + + iMMSFeatureSupported = + FeatureManager::FeatureSupported( KFeatureIdMMS ); + + iFindItemVoIPExtension = CFindItemVoIPExtension::NewL(); + + iAudioMessagingFeatureSupported = + FeatureManager::FeatureSupported( KFeatureIdAudioMessaging ); + + iEmailOverSmsFeatureSupported = + FeatureManager::FeatureSupported( KFeatureIdEmailOverSms ); + + iEmailUiFeatureSupported = + FeatureManager::FeatureSupported( KFeatureIdEmailUi ); + + LoadResourceFileL(); + } + +// ----------------------------------------------------------------------------- +// CFindItemMenu::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CFindItemMenu* CFindItemMenu::NewL( const TInt aCommandId ) + { + CFindItemMenu* self = CFindItemMenu::NewLC( aCommandId ); + CleanupStack::Pop(); + return self; + } + +// ----------------------------------------------------------------------------- +// CFindItemMenu::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +EXPORT_C CFindItemMenu* CFindItemMenu::NewLC( const TInt aCommandId ) + { + + CFindItemMenu* self = new (ELeave) CFindItemMenu; + CleanupStack::PushL( self ); + self->ConstructL( aCommandId ); + return self; + } + +// ----------------------------------------------------------------------------- +// CFindItemMenu::~CFindItemMenu +// Default destructor +// ----------------------------------------------------------------------------- +// +CFindItemMenu::~CFindItemMenu() + { + delete iMPEngineApi; + if( iMPEngineDllLoaded ) + { + iMPEngineDll.Close(); + } + + // Unload the resourcefile + iResLoader.Close(); + delete iFindItemMenuItemString; + delete iFindItemUrlItemString; + delete iFindItemMailItemString; + delete iFindItemPhoneItemString; + + delete iFindItemVoIPExtension; + + if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) + { + delete iFindItemTelInternetItemString; + } + +#ifndef RD_VIRTUAL_PHONEBOOK + delete iPbkEngine; + delete iPbkDataSave; + if ( iRPbkResourceFile ) + { + iRPbkResourceFile->Close(); + } + delete iRPbkResourceFile; +#endif // !RD_VIRTUAL_PHONEBOOK + delete iSendUi; + delete iSenderDescriptor; + + delete iServiceHandler; + + delete iCommonUiRepositoryWatcher; + delete iCommonUiRepository; + + + delete iCallbackNumber; + delete iSchemeHandler; + + delete iDialData; + + delete iSenderDisplayText; + } + +// ----------------------------------------------------------------------------- +// CFindItemMenu::LoadResourceFileL +// Loads the resource for menuitems +// ----------------------------------------------------------------------------- +// +void CFindItemMenu::LoadResourceFileL() + { + TFileName fileName( KResFileName ); + iResLoader.OpenL( fileName ); + + // Read menu item's names from resource r_finditemmenu_menu_item + iFindItemMenuItemString = + iCoeEnv->AllocReadResourceL( R_FINDITEMMENU_MENU_ITEM ); + iFindItemUrlItemString = + iCoeEnv->AllocReadResourceL( R_FINDITEMMENU_URL_ITEM ); + iFindItemMailItemString = + iCoeEnv->AllocReadResourceL( R_FINDITEMMENU_MAIL_ITEM ); + iFindItemPhoneItemString = + iCoeEnv->AllocReadResourceL( R_FINDITEMMENU_PHONE_ITEM ); + if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) ) + { + iFindItemTelInternetItemString = + iCoeEnv->AllocReadResourceL( R_FINDITEMMENU_TELINTERNET_ITEM ); + } + } + +// ----------------------------------------------------------------------------- +// CFindItemMenu::CommandIsValidL +// Allows the application's HandleCommandL() method to switch appropriately +// on menuselections +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CFindItemMenu::CommandIsValidL( const TInt aCommandId ) const + { + if ( (iFindItemMenuItemAdded && ( aCommandId > iFindItemCommandId && + aCommandId <= (iFindItemCommandId + (iFindItemVoIPExtension->IsVoIPSupported()?4:3)))) // traditional find + || + (!iFindItemMenuItemAdded && + // normal autofind command. Let call ui to handle the VoIP profile + // count. + ( ( aCommandId >= EFindItemCmdCall && + aCommandId <= EFindItemCmdSendAudio ) || + // or autofind AIW command + ( iServiceHandler && + ( iServiceHandler->ServiceCmdByMenuCmd( aCommandId ) == KAiwCmdCall || + iServiceHandler->ServiceCmdByMenuCmd( aCommandId ) == + KAiwCmdAssign ) ) ) ) ) + { + return ETrue; + } + return EFalse; + } + +// ----------------------------------------------------------------------------- +// CFindItemMenu::DisplayFindItemMenuItemL +// +// Inserts the FindItem menu item into menupane +// ----------------------------------------------------------------------------- +// +EXPORT_C void CFindItemMenu::DisplayFindItemMenuItemL( + CEikMenuPane& aMenuPane, + const TInt aIndex ) + { + // Call this from DynInitMenuPaneL to add a find item menu item to your menu + AddMenuItemL( + aMenuPane, + iFindItemCommandId, + aIndex, + R_FINDITEMMENU_MENU, + *iFindItemMenuItemString ); + + iFindItemMenuItemAdded = ETrue; + } + +// ----------------------------------------------------------------------------- +// CFindItemMenu::DisplayFindItemCascadeMenuL +// Displays the FindItem cascade menu +// ----------------------------------------------------------------------------- +// +EXPORT_C void CFindItemMenu::DisplayFindItemCascadeMenuL( + CEikMenuPane& aMenuPane ) const + { + // Call this from DynInitMenuPaneL to add a find item's cascading menu + // items to your menu + if ( iFindItemMenuItemAdded ) + { + AddMenuItemL( + aMenuPane, + iFindItemCommandId + 1, + 0, + 0, + *iFindItemPhoneItemString ); + + if ( iFindItemVoIPExtension->IsVoIPSupported() ) + { + AddMenuItemL( + aMenuPane, + iFindItemCommandId + 4, + 0, + 0, + *iFindItemTelInternetItemString ); + } + + if ( iEmailUiFeatureSupported ) + { + AddMenuItemL( + aMenuPane, + iFindItemCommandId + 2, + 0, + 0, + *iFindItemMailItemString ); + } + + AddMenuItemL( + aMenuPane, + iFindItemCommandId + 3, + 0, + 0, + *iFindItemUrlItemString ); + } + } + +// ----------------------------------------------------------------------------- +// AddMenuItemL +// Adds the menu item to menupane +// ----------------------------------------------------------------------------- +// +void CFindItemMenu::AddMenuItemL( + CEikMenuPane& aMenuPane, + TInt aCommandId, + TInt aIndex, + TInt aCascadeId, + const TDesC& aText ) const + { + CEikMenuPaneItem::SData data; + data.iCascadeId = aCascadeId; + data.iFlags = 0; + data.iText = aText; + data.iCommandId = aCommandId; + if ( aIndex == 0 ) + { + aMenuPane.AddMenuItemL( data ); + } + else + { + aMenuPane.AddMenuItemL( data, aIndex ); + } + } + +// ----------------------------------------------------------------------------- +// CFindItemEngine::TFindItemSearchCase CFindItemMenu::SearchCase +// Gives a search case for a command id +// Use the return value when creating a CFindItemDialog. +// ----------------------------------------------------------------------------- +// +EXPORT_C CFindItemEngine::TFindItemSearchCase CFindItemMenu::SearchCase( + const TInt aCommandId ) const + { + switch ( aCommandId - iFindItemCommandId ) + { + case 1: + return CFindItemEngine::EFindItemSearchPhoneNumberBin; + case 2: + return CFindItemEngine::EFindItemSearchMailAddressBin; + case 3: + return CFindItemEngine::EFindItemSearchURLBin; + case 4: + return static_cast + ( CFindItemEngine::EFindItemSearchPhoneNumberBin | + CFindItemEngine::EFindItemSearchMailAddressBin ); + default: + __ASSERT_DEBUG( 0, Panic( ENoSearchCase ) ); + return CFindItemEngine::EFindItemSearchPhoneNumberBin; + } + } + +EXPORT_C void CFindItemMenu::AddItemFindMenuL( + CItemFinder* aItemFinder, + CEikMenuPane* aMenuPane, + TInt aIndex, + const TDesC& aSenderDescriptor, + TBool aKnownSender, + TBool aIsContextMenu ) + { + // create items + iIsSenderKnown = aKnownSender; + delete iSenderDescriptor; + iSenderDescriptor = 0; + iSenderDescriptor = aSenderDescriptor.AllocL(); + + iAutomaticFind = aItemFinder; + + iMenuPane = aMenuPane; + + iIndex = aIndex; + + iIsContextMenu = aIsContextMenu; + + UpdateItemFinderMenuL(); + } + +EXPORT_C void CFindItemMenu::UpdateItemFinderMenuL( + TInt aResource, + CEikMenuPane* aMenuPane ) + { + if ( !iServiceHandler ) + { + AttachItemFinderMenuL( 0 ); // param not really used + } + + CItemFinder::TItemType itemType = iAutomaticFind ? iAutomaticFind->CurrentItemExt().iItemType : CItemFinder::ENoneSelected; + if ( aResource != -1 && aMenuPane ) + { + if( aResource == R_FINDMENU_CALLUI_AIW_SUBMENU ) + { + //Show full call command when number type is not SIP URI or + //number type is phone number or + //it is possible to call sender or callback number + if ( ( itemType != CItemFinder::EEmailAddress || + ( itemType == CItemFinder::EEmailAddress && + !iFindItemVoIPExtension->VoIPProfilesExistL() ) ) && + ( itemType == CItemFinder::EPhoneNumber || + ( iSenderDescriptor->Length() && + iSenderDescType == CItemFinder::EPhoneNumber ) || + ( iCallbackNumber && iCallbackNumber->Length() ) ) ) + { + iServiceHandler->InitializeMenuPaneL( + *aMenuPane, + aResource, + EFindMenuPlaceHolderCallUI, + iServiceHandler->InParamListL() ); + } + //Show only Internet call command in Call submenu when + //Number type is SIP URI + else + { + CAiwGenericParamList* inList = CAiwGenericParamList::NewLC(); + + // SIP Address + TAiwGenericParam param( EGenericParamSIPAddress ); + inList->AppendL( param ); + + iServiceHandler->InitializeMenuPaneL( + *aMenuPane, + aResource, + EFindMenuPlaceHolderCallUI, + *inList ); + + CleanupStack::PopAndDestroy(); // inList + } + + return; + } + +#ifdef RD_VIRTUAL_PHONEBOOK + // Aiw Contacts + else if ( aResource == R_FINDMENU_CONTACTS_AIW_SUBMENU ) + { + if ( ( ( ( !iIsSenderKnown && iSenderDescriptor->Length() ) || + iCallbackNumber ) && + itemType == CItemFinder::ENoneSelected ) || + itemType != CItemFinder::ENoneSelected ) + { + using namespace AiwContactAssign; + + CAiwGenericParamList& inList = iServiceHandler->InParamListL(); + + // Contact Assign Data + TAiwGenericParam param( EGenericParamContactAssignData ); + TAiwSingleContactAssignDataV1 assignData; + assignData.SetFlags( 0 ); // Reset + param.Value().Set( + TAiwSingleContactAssignDataV1Pckg( assignData ) ); + inList.AppendL( param ); + + // Contact Data Type + param.Reset(); + param.SetSemanticId( EGenericParamPhoneNumber ); + inList.AppendL( param ); + + iServiceHandler->InitializeMenuPaneL( + *aMenuPane, + aResource, + EFindMenuCmdLast, + inList ); + + return; + } + } +#endif // RD_VIRTUAL_PHONEBOOK + +#ifndef RD_VIRTUAL_PHONEBOOK + else if ( iPbkDataSave ) + { + iPbkDataSave->DynInitMenuPaneL( aResource, aMenuPane ); + } +#endif // !RD_VIRTUAL_PHONEBOOK + + return; + } + + TInt index = iIndex; + + TBuf tempBuf; + + // Adds menu items depending the selected item + switch ( itemType ) + { + case CItemFinder::EPhoneNumber: + { +#ifdef RD_VOIP_REL_2_2 + if ( FeatureManager::FeatureSupported(KFeatureIdCommonVoip ) ) + { + // show call menu if allowed + if ( !( iMenuItemFlags & CFindItemMenu::ECallItem ) ) + { + // Call + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_CALL ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCall, + ( iIsContextMenu ? EFindItemContextMenuPlaceHolder : index ), + 0, + tempBuf ); + } + // if context menu, we will show call item anyway + else if ( iIsContextMenu ) + { + // Call + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_CALL ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCall, + EFindItemContextMenuPlaceHolder, + 0, + tempBuf ); + } + } + else + { + // Call + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_CALL ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCall, + ( iIsContextMenu ? EFindItemContextMenuPlaceHolder : index ), + 0, + tempBuf ); + } + index = EFindItemCmdCall; +#else + // Call + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_CALL ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCall, + ( iIsContextMenu ? EFindItemContextMenuPlaceHolder : index ), + 0, + tempBuf ); + index = EFindItemCmdCall; +#endif // RD_VOIP_REL_2_2 + // Write + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_MESSAGE_SUB ); + AddMenuItemL( + *iMenuPane, + EFindItemSubMenuSend, + index, + 0,//R_FINDITEM_NUMBER_MESSAGE_SUBMENU, + tempBuf ); + index = EFindItemSubMenuSend; + + break; + } + case CItemFinder::EUrlAddress: + { + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_GOTO_URL ); + + // check if not rstp + if ( iAutomaticFind->CurrentItemExt().iItemDescriptor->FindF( KRtspUrlAddress ) == KErrNotFound ) + { + AddMenuItemL( + *iMenuPane, + EFindItemCmdGoToUrl, + ( iIsContextMenu ? EFindItemContextMenuPlaceHolder : index ), + 0, + tempBuf); + index = EFindItemCmdGoToUrl; + + if ( !iIsContextMenu ) + { + // Add bookmark + iCoeEnv->ReadResourceL( + tempBuf, R_FINDITEMMENU_ADD_BOOKMARK ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdAddToBookmark, + index, + 0, + tempBuf ); + index = EFindItemCmdAddToBookmark; + } + } + else + { + AddMenuItemL( + *iMenuPane, + EFindItemCmdGoToRstp, + ( iIsContextMenu ? EFindItemContextMenuPlaceHolder : index ), + 0, + tempBuf ); + index = EFindItemCmdGoToRstp; + + if ( !iIsContextMenu ) + { + iCoeEnv->ReadResourceL( + tempBuf, R_FINDITEMMENU_ADD_TO_GALLERY ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdAddToGallery, + index, + 0, + tempBuf ); + index = EFindItemCmdAddToGallery; + } + } + break; + } + case CItemFinder::EEmailAddress: + { + // Checks VoIP profile count and local variation + if ( iIsContextMenu && iFindItemVoIPExtension->VoIPProfilesExistL() ) + { + //Call + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_CALL ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCall, + EFindItemContextMenuPlaceHolder, + 0, + tempBuf ); + index = EFindItemCmdCall; // Replaces the call ui menu when email + // field is selected. + } + + // Write + if( iEmailOverSmsFeatureSupported || iMMSFeatureSupported || + iEmailUiFeatureSupported ) // Sometimes submenu can be empty. + { + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_MESSAGE_SUB ); + AddMenuItemL( + *iMenuPane, + EFindItemSubMenuSend, + ( ( iIsContextMenu && + !iFindItemVoIPExtension->VoIPProfilesExistL() ) ? + EFindItemContextMenuPlaceHolder : index ), + 0,//R_FINDITEM_EMAIL_MESSAGE_SUBMENU, + tempBuf ); + index = EFindItemSubMenuSend; + } + break; + } + case CItemFinder::EUriScheme: + { + // Use + iCoeEnv->ReadResourceL( tempBuf, R_QTN_OPTIONS_SCHEME_USE ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdUse, + ( iIsContextMenu ? EFindItemContextMenuPlaceHolder : index ), + 0, + tempBuf ); + index = EFindItemCmdUse; + break; + } + default: + { + // Something else, probably nothing selected or new type which we + // don't support. + break; + } + } + // Call + if ( + ( itemType == CItemFinder::ENoneSelected ) && + ( + ( + iSenderDescriptor->Length() && + iSenderDescType == CItemFinder::EPhoneNumber || + iSenderDescriptor->Length() && + iSenderDescType == CItemFinder::EEmailAddress && + iFindItemVoIPExtension->VoIPProfilesExistL() + ) + || + ( iCallbackNumber && iCallbackNumber->Length() ) ) + + || + ( itemType == CItemFinder::EEmailAddress && + iFindItemVoIPExtension->VoIPProfilesExistL() && + !iIsContextMenu ) + ) + { +#ifdef RD_VOIP_REL_2_2 + if ( FeatureManager::FeatureSupported(KFeatureIdCommonVoip ) ) + { + if ( !iMenuItemFlags & CFindItemMenu::ECallItem ) + { + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_CALL ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCall, + iIndex, + 0, + tempBuf ); // this goes always first + if ( index == iIndex ) + { + index = EFindItemCmdCall; // other commands are added after this. + } + } + } + else + { + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_CALL ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCall, + iIndex, + 0, + tempBuf ); // this goes always first + if ( index == iIndex ) + { + index = EFindItemCmdCall; // other commands are added after this. + } + } +#else + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_CALL ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCall, + iIndex, + 0, + tempBuf ); // this goes always first + if ( index == iIndex ) + { + index = EFindItemCmdCall; // other commands are added after this. + + } +#endif // RD_VOIP_REL_2_2 + } + // Highlight status + TInt highlight = 0; + if ( iCommonUiRepository ) + { + iCommonUiRepository->Get( KCuiAutomaticHighlight, highlight ); + } + if ( !iIsContextMenu ) + { + // Activate/Deactivate find + if ( highlight ) + { + iCoeEnv->ReadResourceL( tempBuf, R_QTN_FIND_DEACTIVATE_OPTION ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdDisableAutoFind, + index, + 0, + tempBuf ); + } + else + { + iCoeEnv->ReadResourceL( tempBuf, R_QTN_FIND_ACTIVATE_OPTION ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdEnableAutoFind, + index, + 0, + tempBuf ); + } + + // Copy + + TInt len = 0; + if ( iAutomaticFind && iAutomaticFind->CurrentItemExt().iItemType != CItemFinder::ENoneSelected ) + { + HBufC* item = iAutomaticFind->CurrentSelection().AllocLC(); + len = item->Length(); + CleanupStack::PopAndDestroy( ); + } + + if( (!iAutomaticFind || len != 0) && + highlight && + ( itemType != CItemFinder::ENoneSelected || + iSenderHighlighted ) ) + { + iCoeEnv->ReadResourceL( tempBuf, R_FINDITEMMENU_COPY ); + AddMenuItemL( + *iMenuPane, + EFindItemCmdCopy, + index, + 0, + tempBuf ); + } + + + } + + // Add to contacts + if ( ( itemType != CItemFinder::EUriScheme ) && + !( itemType == CItemFinder::EUrlAddress && + iIsContextMenu ) && + ( ( ( ( !iIsSenderKnown && + iSenderDescriptor->Length() ) || + iCallbackNumber ) && + itemType == CItemFinder::ENoneSelected ) || + itemType != CItemFinder::ENoneSelected ) ) + { + AddMenuItemL( + *iMenuPane, + EFindItemCmdCreateContactCard, + index, + 0, + KNullDesC ); +#ifndef RD_VIRTUAL_PHONEBOOK + iPbkDataSave->AddMenuItemsL( + iMenuPane, + EFindItemCmdCreateContactCard ); +#else + iMenuPane->SetItemDimmed( + EFindItemCmdCreateContactCard, ETrue ); + iMenuPane->AddMenuItemsL( + R_FINDMENU_CONTACTS_AIW_ITEM, + EFindItemCmdCreateContactCard ); +#endif // !RD_VIRTUAL_PHONEBOOK + } + // Diming + if ( !iIsContextMenu ) + { + TInt dummy = 0; + if ( iMenuPane->MenuItemExists( EFindItemMenuPlaceHolder, dummy ) ) + { + iMenuPane->SetItemDimmed( EFindItemMenuPlaceHolder, ETrue ); + } + } + else + { + TInt dummy = 0; + if ( iMenuPane->MenuItemExists( EFindItemContextMenuPlaceHolder, dummy ) ) + { + iMenuPane->SetItemDimmed( EFindItemContextMenuPlaceHolder, ETrue ); + } + } + // Replace cmd call with AIW menu if more than one option available in AIW + // menu + // Note: count of VoIP profiles is not static. If phone contains VoIP + // profiles there must be Internet call command in call submenu. + TInt dummy = 0; + if ( ( !iHideCallMenu || + ( iFindItemVoIPExtension->IsVoIPSupported() && + iFindItemVoIPExtension->VoIPProfilesExistL() ) ) && + iMenuPane->MenuItemExists( EFindItemCmdCall, dummy ) ) + { + iMenuPane->SetItemDimmed( EFindItemCmdCall, ETrue ); + iMenuPane->AddMenuItemsL( + R_FINDMENU_CALLUI_AIW_ITEM, + EFindItemCmdCall ); + } + } + +EXPORT_C void CFindItemMenu::HandleItemFinderCommandL( TInt aCommand ) + { + switch ( aCommand ) + { + case EFindItemCmdCall: + { + CallL(); + break; + } + case EFindItemSubMenuSend: + { + TSendingCapabilities sendingCapabilities; + sendingCapabilities.iFlags = TSendingCapabilities::ESupportsEditor; + CArrayFixFlat* mtmFilter = new(ELeave) CArrayFixFlat( 1 ); + CleanupStack::PushL(mtmFilter); + CItemFinder::TItemType itemType = iAutomaticFind ? iAutomaticFind->CurrentItemExt().iItemType : CItemFinder::ENoneSelected; + + mtmFilter->AppendL(KSenduiMtmPostcardUid);// dim postcard + // Hide SMS if not supported + + #ifndef RD_UNIFIED_EDITOR + if ( !iEmailOverSmsFeatureSupported ) + { + mtmFilter->AppendL(KSenduiMtmSmsUid); + } + // Hide MMS if not supported + if (!iMMSFeatureSupported) + { + mtmFilter->AppendL(KSenduiMtmMmsUid); + } + #endif + + // Hide E-Mail if nosupported or phonenumber + if ( !iEmailUiFeatureSupported || itemType == CItemFinder::EPhoneNumber ) + { + mtmFilter->AppendL(KSenduiMtmSmtpUid); + mtmFilter->AppendL(KSenduiMtmImap4Uid); + mtmFilter->AppendL(KSenduiMtmPop3Uid); + mtmFilter->AppendL(KSenduiMtmSyncMLEmailUid); + } + // Hide Audio if not supported or E-mail address + if( !iAudioMessagingFeatureSupported || itemType == CItemFinder::EEmailAddress) + { + mtmFilter->AppendL(KSenduiMtmAudioMessageUid); + } + TUid uid = iSendUi->ShowTypedQueryL( CSendUi::EWriteMenu, NULL, sendingCapabilities, mtmFilter ); + + CleanupStack::PopAndDestroy(); + if ( uid == KNullUid ) + { + break; + } + SendMessageL(uid); + + break; + } + + case EFindItemCmdGoToUrl: + { + LaunchGenericUriL(); + break; + } + case EFindItemCmdGoToRstp: + { + LaunchGenericUriL(); + break; + } + + case EFindItemCmdAddToBookmark: + { + AddToBookmarkL(); + break; + } + case EFindItemCmdCreateContactCardSub1: + case EFindItemCmdCreateContactCardSub2: + case EFindItemCmdCreateContactCardSub3: + { + CreateContactCardL( aCommand ); + // Restore original client application icon back to context pane. + CEikStatusPane* statusPane = + ( (CAknAppUi*)CEikonEnv::Static()->EikAppUi() )->StatusPane(); + CCoeControl* contextControl = + statusPane->ControlL( TUid::Uid( EEikStatusPaneUidContext ) ); + CAknContextPane* contextPane = + static_cast( contextControl ); + contextPane->SetPictureToDefaultL(); + break; + } + case EFindItemCmdAddToGallery: + { + AddToGalleryL(); + break; + } + + case EFindItemCmdDisableAutoFind: + { + if (iCommonUiRepository) + { + iCommonUiRepository->Set( KCuiAutomaticHighlight, 0 ); + } + AutoFindStatusChangedL(); + break; + } + + case EFindItemCmdEnableAutoFind: + { + if (iCommonUiRepository) + { + iCommonUiRepository->Set( KCuiAutomaticHighlight, 1 ); + } + AutoFindStatusChangedL(); + break; + } + + case EFindItemCmdUse: + { + LaunchGenericUriL(); + break; + } + + case EFindItemCmdCopy: + { + CopyToClipboardL(); + break; + } + default: + { + TInt aiwCmd = iServiceHandler->ServiceCmdByMenuCmd( aCommand ); + TBool calltypeInternetCall( EFalse ); + if ( iFindItemVoIPExtension->VoIPProfilesExistL() && iAutomaticFind && iAutomaticFind->CurrentItemExt().iItemType == CItemFinder::EEmailAddress ) + { + calltypeInternetCall = ETrue; + } + + // Call via Aiw + if ( aiwCmd == KAiwCmdCall && FormatDialDataL( calltypeInternetCall ) ) + { + if ( !iDialData ) + { + break; + } + + CAiwGenericParamList& paramList = + iServiceHandler->InParamListL(); + + iDialData->FillInParamListL( paramList ); + + iServiceHandler->ExecuteMenuCmdL( + aCommand, + paramList, + iServiceHandler->OutParamListL(), + 0, // No options used. + 0 ); // no dial results are wanted. + } +#ifdef RD_VIRTUAL_PHONEBOOK + // Contacts via Aiw + else if ( aiwCmd == KAiwCmdAssign ) + { + CreateContactCardL( aCommand ); + } +#endif // RD_VIRTUAL_PHONEBOOK + break; + } + } + } + +EXPORT_C void CFindItemMenu::HandleCallL( const TDesC& aSenderDescriptor ) + { + AttachItemFinderMenuL( 0 ); // Make sure that this get called even if + // caller won't call this + + delete iSenderDescriptor; + iSenderDescriptor = 0; + iSenderDescriptor = aSenderDescriptor.AllocL(); + + CallL(); + } + +EXPORT_C void CFindItemMenu::HandleVoIPCallL( const TDesC& aSenderDescriptor ) + { + AttachItemFinderMenuL( 0 ); // Make sure that this get called even if + // caller won't call this + + delete iSenderDescriptor; + iSenderDescriptor = 0; + iSenderDescriptor = aSenderDescriptor.AllocL(); + + VoIPCallL(); + } + +void CFindItemMenu::CallL() + { + if ( !iDialData ) + { + return; + } + + if ( !FormatDialDataL( EFalse ) ) + { + return; + } + + // Create Call W/O Menu + CAiwGenericParamList& paramList = + iServiceHandler->InParamListL(); + + iDialData->FillInParamListL( paramList ); + + iServiceHandler->ExecuteServiceCmdL( + KAiwCmdCall, + paramList, + iServiceHandler->OutParamListL(), + 0, // No options used. + NULL ); + } + +void CFindItemMenu::VoIPCallL() + { + if ( !iDialData ) + { + return; + } + if ( !FormatDialDataL( ETrue ) || + !iFindItemVoIPExtension->IsVoIPSupported() ) + { + return; + } + + // Create Call W/O Menu + CAiwGenericParamList& paramList = iServiceHandler->InParamListL(); + + iDialData->FillInParamListL( paramList ); + + iServiceHandler->ExecuteServiceCmdL( + KAiwCmdCall, + paramList, + iServiceHandler->OutParamListL(), + 0, // No options used. + NULL ); + } + +void CFindItemMenu::SendMessageL( const TUid aMtmUid ) + { + HBufC* parsedAddress = 0; + TBool isNumber = EFalse; + if ( iAutomaticFind && iAutomaticFind->CurrentItemExt().iItemType == CItemFinder::EEmailAddress ) + { + parsedAddress = iAutomaticFind->CurrentItemExt().iItemDescriptor; + } + else + { + // if sender descriptor is something else than phone number it will + // still go through this brach.. + TBool numberSelected = ( iAutomaticFind && iAutomaticFind->CurrentItemExt().iItemType == CItemFinder::EPhoneNumber ); + parsedAddress = ( numberSelected ? iAutomaticFind->CurrentItemExt().iItemDescriptor : iSenderDescriptor)->AllocLC(); + TPtr numberPtr = parsedAddress->Des(); + CommonPhoneParser::ParsePhoneNumber( numberPtr, CommonPhoneParser::EPlainPhoneNumber ); + AknTextUtils::ConvertDigitsTo( numberPtr, EDigitTypeWestern ); + isNumber = ETrue; + } + + CMessageData* messageData = CMessageData::NewL(); + CleanupStack::PushL( messageData ); + messageData->AppendToAddressL( parsedAddress->Des() ); + iSendUi->CreateAndSendMessageL( aMtmUid,messageData ); + CleanupStack::PopAndDestroy( isNumber ? 2 : 1 ); // messageData, number + } + +void CFindItemMenu::GoToUrlL( TUid /*aHandlerAppUid*/ ) + { + // Scheme handler can handle this + } + +void CFindItemMenu::AddToBookmarkL() + { + // Create an item + CFavouritesItem* item = CFavouritesItem::NewLC(); + item->SetParentFolder( KFavouritesRootUid ); + item->SetType( CFavouritesItem::EItem ); + // Read default name from resources + RConeResourceLoader ldr( *iCoeEnv ); + + TFileName dialogResource( KDialogResourceName ); + + ldr.OpenL( dialogResource ); + CleanupClosePushL( ldr ); + + // Read default name from resources + HBufC* defaultName = + iCoeEnv->AllocReadResourceLC( R_FINDITEM_DEFAULT_BOOKMARK_NAME ); + + TBuf retName; + retName.Copy( defaultName->Des() ); + + // Query bookmark name from user + CAknTextQueryDialog* dlg = CAknTextQueryDialog::NewL( retName ); + dlg->SetMaxLength( KMaxBookmarkNameLength ); + if ( !dlg->ExecuteLD( R_FINDITEM_BOOKMARK_QUERY_DIALOG ) ) + { + // User press cancel - do not add bookmark + CleanupStack::PopAndDestroy( 3 ); // item, defaultName, resourceLoader + return; + } + + item->SetNameL( retName ); + item->SetUrlL( iAutomaticFind->CurrentItemExt().iItemDescriptor->Des() ); + + RFavouritesSession sess; + RFavouritesDb db; + + User::LeaveIfError( sess.Connect() ); + CleanupClosePushL( sess ); + User::LeaveIfError( db.Open( sess, KBrowserBookmarks ) ); + CleanupClosePushL( db ); + + // add item + db.Add( *item, ETrue ); + // Close the database. + db.Close(); + + HBufC* msgBuffer = iCoeEnv->AllocReadResourceLC( R_FINDITEM_BOOKMARK_SAVED ); + CAknConfirmationNote* note = new (ELeave)CAknConfirmationNote( ETrue ); + note->ExecuteLD( *msgBuffer ); + + CleanupStack::PopAndDestroy( 6 ); // item, db, sess, resourceLoader, + // defaultName, msgBuffer + } + +void CFindItemMenu::CreateContactCardL( TInt aCommandId ) + { + CItemFinder::TItemType itemType = iSenderDescType; // default + HBufC* item = 0; + if ( iAutomaticFind && iAutomaticFind->CurrentItemExt().iItemType != CItemFinder::ENoneSelected ) + { + item = iAutomaticFind->CurrentItemExt().iItemDescriptor->AllocLC(); + itemType = iAutomaticFind->CurrentItemExt().iItemType; + } + else if ( !iCallbackNumber ) // default type if ok + { + item = iSenderDescriptor->AllocLC(); + } + else if ( iIsSenderKnown || !iSenderDescriptor->Length() ) + { + // callbacknumber exists and sender's address is already in phonebook + // or sender's number is NULL + item = iCallbackNumber->AllocLC(); + } + else + { + TInt index = 0; + item = ChooseNumberQueryL( index ); + if (item) + { + CleanupStack::PushL( item ); + if ( index == EFindUICallbackNumber ) // sender type is still + // default + { + itemType = CItemFinder::EPhoneNumber; + } + } + else + { + return; + } + } +#ifndef RD_VIRTUAL_PHONEBOOK + CArrayPtrFlat *fieldArray = + new(ELeave)CArrayPtrFlat( 1 ); + CleanupStack::PushL( fieldArray ); + + for ( TInt i = 0; i < iPbkEngine->FieldsInfo().Count(); i++ ) + { + CPbkFieldInfo* fieldInfo = iPbkEngine->FieldsInfo()[ i ]; + // Only interested in text storage fields + if ( !( fieldInfo->FieldStorageType() == KStorageTypeText ) ) + { + continue; + } + + if ( itemType == CItemFinder::EPhoneNumber && + ( fieldInfo->IsPhoneNumberField() || +#ifdef __VOIP + iFindItemVoIPExtension->IsVoIPSupported() && +#else + iVoIPFeatureSupported && +#endif + fieldInfo->FieldId() == EPbkFieldIdVOIP ) ) + { + fieldArray->AppendL( fieldInfo ); + } + else if ( itemType == CItemFinder::EEmailAddress && + ( fieldInfo->FieldId() == EPbkFieldIdEmailAddress || +#ifdef __VOIP + iFindItemVoIPExtension->IsVoIPSupported() && +#else + iVoIPFeatureSupported && +#endif + fieldInfo->FieldId() == EPbkFieldIdVOIP ) ) + { + fieldArray->AppendL(fieldInfo); + } + else if ( ( itemType == CItemFinder::EUrlAddress || + itemType == CItemFinder::EUriScheme ) && + fieldInfo->FieldId() == EPbkFieldIdURL ) + { + fieldArray->AppendL( fieldInfo ); + } + } +#endif // !RD_VIRTUAL_PHONEBOOK + + TPtr itemDes = item->Des(); + +#ifndef RD_VIRTUAL_PHONEBOOK + iPbkDataSave->HandleCommandL( aCommandId, *fieldArray, *item ); + CleanupStack::PopAndDestroy( 2 ); // fieldArray, item +#else //RD_VIRTUAL_PHONEBOOK + using namespace AiwContactAssign; + + CAiwGenericParamList& inList = iServiceHandler->InParamListL(); + + // Contact Assign Data. + TAiwGenericParam param( EGenericParamContactAssignData ); + TAiwSingleContactAssignDataV1 assignData; + assignData.SetFlags( 0 ); + param.Value().Set( TAiwSingleContactAssignDataV1Pckg( assignData ) ); + inList.AppendL( param ); + + // Contact Data Type. + param.Reset(); + switch( itemType ) // Resolve type. + { + case CItemFinder::EPhoneNumber: // Phone number + param.SetSemanticId( EGenericParamPhoneNumber ); + // convert phone number. + CommonPhoneParser::ParsePhoneNumber( + itemDes, CommonPhoneParser::EPhoneClientNumber ); + break; + case CItemFinder::EEmailAddress: // E-mail + param.SetSemanticId( EGenericParamEmailAddress ); + break; + case CItemFinder::EUrlAddress: // URL + case CItemFinder::EUriScheme: // URI + param.SetSemanticId( EGenericParamURL ); + break; + default: + CleanupStack::PopAndDestroy( 1 ); // item + return; // unknown item type. + } + param.Value().Set( itemDes ); + inList.AppendL( param ); + + iServiceHandler->ExecuteMenuCmdL( + aCommandId, + inList, + iServiceHandler->OutParamListL(), + 0, + &iCallback ); + CleanupStack::PopAndDestroy( 1 ); // item +#endif // !RD_VIRTUAL_PHONEBOOK + } + +void CFindItemMenu::AddToGalleryL() + { + _LIT( KRamFileExtension,".ram" ); + TFileName fileName; + iCoeEnv->ReadResourceL( fileName, R_FINDITEMMENU_DEFAULT_GALL_NAME ); + fileName.Append( KRamFileExtension ); + if ( AknCommonDialogs::RunSaveDlgLD( + fileName, R_MEMORY_SELECTION_LOCATIONS ) ) + { + CDesCArrayFlat* array = new (ELeave)CDesCArrayFlat( 1 ); + CleanupStack::PushL( array ); + array->AppendL( iAutomaticFind->CurrentItemExt().iItemDescriptor->Des() ); + TInt err = KErrNone; + if( !iMPEngineDllLoaded ) + { + LoadMPEngineApiL(); + } + err = iMPEngineApi->CreateNewLinkFileL( fileName, array, ETrue ); + CleanupStack::PopAndDestroy( 1 ); + + if ( err == KErrNone ) + { + // Show note + HBufC* msgBuffer = + iCoeEnv->AllocReadResourceLC( R_FINDITEMMENU_LINK_SAVED ); + CAknConfirmationNote* note = + new (ELeave) CAknConfirmationNote( ETrue ); + note->ExecuteLD( *msgBuffer ); + CleanupStack::PopAndDestroy(); // msgBuffer + } + } + } + +EXPORT_C void CFindItemMenu::SetSenderDescriptorType( + CItemFinder::TItemType aType ) + { + iSenderDescType = aType; + } + +EXPORT_C void CFindItemMenu::AttachItemFinderMenuL( TInt /*aResource*/ ) + { + if ( iServiceHandler ) // this method should be called once and only once. + { + return; + } +#ifndef RD_VIRTUAL_PHONEBOOK + iRPbkResourceFile = new (ELeave)RPbkViewResourceFile( *iCoeEnv ); + iRPbkResourceFile->OpenL(); + iPbkEngine = CPbkContactEngine::NewL(); + iPbkDataSave = CPbkDataSaveAppUi::NewL( *iPbkEngine ); +#endif // !RD_VIRTUAL_PHONEBOOK + iSendUi = CSendUi::NewL(); + + TRAPD( ret, iCommonUiRepository = CRepository::NewL( KCRUidCommonUi ) ); + if ( ret == KErrNone ) + { + iCommonUiRepositoryWatcher = CCommonUiRepositoryWatcher::NewL( + KCRUidCommonUi, + KCuiAutomaticHighlight, + CCenRepNotifyHandler::EIntKey, + TCallBack( AutoFindStatusChanged, this ), + iCommonUiRepository ); + } + + // AIW + iServiceHandler = CAiwServiceHandler::NewL(); + + // Call UI + iServiceHandler->AttachMenuL( + R_FINDMENU_CALLUI_AIW_SUBMENU, + R_FINDMENU_CALLUI_AIW_INTEREST ); + + CMyMenuPane* callUiMenu = + new (ELeave) CMyMenuPane( (MEikMenuObserver*)this ); // not used really + CleanupStack::PushL( callUiMenu ); + TResourceReader callUiReader; + iCoeEnv->CreateResourceReaderLC( + callUiReader, R_FINDMENU_CALLUI_AIW_SUBMENU ); + callUiMenu->ConstructFromResourceL( callUiReader ); + CleanupStack::PopAndDestroy(); // callUiReader + + iServiceHandler->InitializeMenuPaneL( + *(CEikMenuPane*)callUiMenu, + R_FINDMENU_CALLUI_AIW_SUBMENU, + EFindMenuPlaceHolderCallUI, + iServiceHandler->InParamListL() ); + + if ( callUiMenu->NumberOfItemsInPane() < 2 ) + { + iHideCallMenu = ETrue; + } + + iServiceHandler->AttachL( R_FINDMENU_CALLUI_AIW_INTEREST ); + CleanupStack::PopAndDestroy(); // callUiMenu + +#ifdef RD_VIRTUAL_PHONEBOOK + // Contacts + iServiceHandler->AttachMenuL( + R_FINDMENU_CONTACTS_AIW_SUBMENU, + R_FINDMENU_CONTACTS_AIW_INTEREST ); +#endif // RD_VIRTUAL_PHONEBOOK + } + +void CFindItemMenu::AutoFindStatusChangedL() + { + if ( iAutomaticFind ) + { + TInt value = 0; + if ( iCommonUiRepository ) + { + iCommonUiRepository->Get( KCuiAutomaticHighlight, value ); + } + if ( value == 1 ) + { + iAutomaticFind->SetFindModeL( CItemFinder::EUrlAddress|CItemFinder::EEmailAddress|CItemFinder::EPhoneNumber ); + } + else + { + iAutomaticFind->SetFindModeL( 0 ); + } + } + } + +TInt CFindItemMenu::AutoFindStatusChanged( TAny* aThis ) + { + CFindItemMenu* me = (CFindItemMenu*)aThis; + TRAPD( err, me->AutoFindStatusChangedL() ); + return err; + } + +TBool CFindItemMenu::FormatDialDataL( TBool aFormatVoIPDialData ) + { + if ( !iDialData ) + { + return EFalse; + } + + TBool numberSelected = ( iAutomaticFind && iAutomaticFind->CurrentItemExt().iItemType == CItemFinder::EPhoneNumber ); + + TBool SIPURISelected = + ( aFormatVoIPDialData && + iAutomaticFind && + iFindItemVoIPExtension->VoIPProfilesExistL() && + iAutomaticFind->CurrentItemExt().iItemType == CItemFinder::EEmailAddress ); + + HBufC* parsedNumber = NULL ; + // Foucs in text body and a phone number has been selected + // Takes number from selected item when SIP URI is selected. + if ( numberSelected || SIPURISelected ) + { + parsedNumber = iAutomaticFind->CurrentItemExt().iItemDescriptor->AllocLC(); + } + else if ( !iCallbackNumber ) // Focus in address control with callback + // number + { + parsedNumber = iSenderDescriptor->AllocLC(); + } + else if ( !( iSenderDescType == CItemFinder::EPhoneNumber && iSenderDescriptor->Length() ) ) + // Eg. Email over Sms with callback number + { + parsedNumber = iCallbackNumber->AllocLC(); + } + else // both callback number and sender number, use query + { + TInt dummy = 0; + parsedNumber = ChooseNumberQueryL( dummy ); + if( parsedNumber ) + { + CleanupStack::PushL( parsedNumber ); + } + else + { + return EFalse; + } + } + TPtr numberPtr = parsedNumber->Des(); + + using namespace AIWDialDataExt; + CommonPhoneParser::ParsePhoneNumber( + numberPtr, CommonPhoneParser::EPhoneClientNumber ); + __ASSERT_ALWAYS( parsedNumber->Length() <= KMaximumPhoneNumberLength, + Panic( ETooLongItem ) ); + AknTextUtils::ConvertDigitsTo( numberPtr, EDigitTypeWestern ); +#ifdef RD_VOIP_REL_2_2 + if ( FeatureManager::FeatureSupported(KFeatureIdCommonVoip ) ) + { + if ( aFormatVoIPDialData ) + { + // sets call type for VoIP + iDialData->SetCallType( CAiwDialData::EAIWVoiP ); + } + } +#endif // RD_VOIP_REL_2_2 + iDialData->SetPhoneNumberL( numberPtr ); + + CleanupStack::PopAndDestroy(); // number; + return ETrue; + } + +void CFindItemMenu::LaunchGenericUriL() + { + if ( iSchemeHandler ) + { + delete iSchemeHandler; + iSchemeHandler = 0; + } + iSchemeHandler = CSchemeHandler::NewL( iAutomaticFind->CurrentItemExt().iItemDescriptor->Des() ); + if ( iAutomaticFind->CurrentItemExt().iItemDescriptor->FindF( KRtspUrlAddress ) != KErrNotFound ) + { + iSchemeHandler->HandleUrlEmbeddedL(); + } + else + { + iSchemeHandler->HandleUrlStandaloneL(); + } + } + +EXPORT_C void CFindItemMenu::SetCallbackNumber( const TDesC& aPhoneNumber ) + { + delete iCallbackNumber; + iCallbackNumber = 0; + iCallbackNumber = aPhoneNumber.Alloc(); + } + +HBufC* CFindItemMenu::ChooseNumberQueryL( TInt& aIndex ) + { + HBufC* ret = 0; + + // First phase construction of menu list + CAknSingleHeadingPopupMenuStyleListBox* phoneNumberList = + new (ELeave) CAknSingleHeadingPopupMenuStyleListBox; + CleanupStack::PushL( phoneNumberList ); + + // Create a popuplist to show the menu list in + CAknPopupList* popupList = + CAknPopupList::NewL( phoneNumberList, R_AVKON_SOFTKEYS_OK_CANCEL ); + CleanupStack::PushL( popupList ); + // Second phase construction of popupList + phoneNumberList->ConstructL( popupList,EAknListBoxMenuList ); + + // Set up menu items + CTextListBoxModel* model = phoneNumberList->Model(); + model->SetOwnershipType( ELbmOwnsItemArray ); + + CDesCArray* phoneNumberListArray = + static_cast( model->ItemTextArray() ); + + HBufC* title; + title = StringLoader::LoadLC( R_QTN_SMS_USENUMBER ); + popupList->SetTitleL( *title ); + CleanupStack::PopAndDestroy( title ); + + _LIT( KStringHeader, "%S\t%S" ); + TBuf <256> string; + HBufC* head; + // sender item + head = StringLoader::LoadLC( R_QTN_SMS_USENUMBER_FROM ); + string.Format( KStringHeader(), head, iSenderDescriptor ); + phoneNumberListArray->AppendL ( string); + CleanupStack::PopAndDestroy( head ); + // callback number + head = StringLoader::LoadLC( R_QTN_SMS_USENUMBER_CALLBACK ); + string.Format( KStringHeader(), head, iCallbackNumber ); + phoneNumberListArray->AppendL( string ); + CleanupStack::PopAndDestroy( head ); + + CleanupStack::Pop( popupList ); + + if ( popupList->ExecuteLD() ) + { + ret = ( phoneNumberList->CurrentItemIndex() == EFindUICallbackNumber ) ? + iCallbackNumber->AllocL() : iSenderDescriptor->AllocL(); + aIndex = phoneNumberList->CurrentItemIndex(); + } + + CleanupStack::PopAndDestroy( phoneNumberList ); + + return ret; + } + +// ----------------------------------------------------------------------------- +// TInt CFindItemMenu::LoadMPEngineApiL +// Load MPEngine Api. +// ----------------------------------------------------------------------------- +void CFindItemMenu::LoadMPEngineApiL() + { + // Memo saving dll loading. + if( !iMPEngineDllLoaded ) + { + if( iMPEngineDll.Load( KCommonUiMPEngineApiLoaderName ) == KErrNone ) + { + iMPEngineDllLoaded = ETrue; + // Request the entry function + MPEngineApiL mpengineApi = + (MPEngineApiL) iMPEngineDll.Lookup( KMPEngineApiDllEntryPoint ); + if( mpengineApi ) + { + // Create the class + iMPEngineApi = (CCommonUiMPEngineApiLoader*) (*mpengineApi)(); + } + } + } + // The wrapper failed to load. + if ( !iMPEngineApi ) + { + User::Leave( KErrNotFound ); + } + } + +// ----------------------------------------------------------------------------- +// TInt CFindItemMenu::CopyToClipboardL +// +// ----------------------------------------------------------------------------- +void CFindItemMenu::CopyToClipboardL() + { + HBufC* item = 0; + TInt len = 0; + if ( iAutomaticFind && iAutomaticFind->CurrentItemExt().iItemType != CItemFinder::ENoneSelected ) + { + item = iAutomaticFind->CurrentSelection().AllocLC(); + len = item->Length(); + } + else if( iSenderHighlighted ) + { + item = iSenderDisplayText->AllocLC(); + len = item->Length(); + } + __ASSERT_DEBUG( len > 0, Panic( ENoItemSelected ) ); + + CPlainText* plainText = CPlainText::NewL( CPlainText::ESegmentedStorage, len ); + CleanupStack::PushL( plainText ); + plainText->InsertL( 0, *item ); + + CClipboard* cb = CClipboard::NewForWritingLC( iCoeEnv->FsSession() ); + plainText->CopyToStoreL( cb->Store(), cb->StreamDictionary(), 0, len ); + cb->CommitL(); + + CleanupStack::PopAndDestroy( 3 ); // item, plainText, cb + // fix for EJCU-7K98TM + CAknNoteDialog* dlg = new (ELeave) CAknNoteDialog(); + dlg->SetTimeout(CAknNoteDialog::EShortTimeout); + dlg->SetTone(CAknNoteDialog::ENoTone); + dlg->ExecuteLD( R_AVKON_NOTE_CONF_COPIED ); + // fix end + } + +EXPORT_C void CFindItemMenu::SetSenderHighlightStatus( TBool aStatus ) + { + iSenderHighlighted = aStatus; + } + +EXPORT_C void CFindItemMenu::SetSenderDisplayText( const TDesC& aText ) + { + delete iSenderDisplayText; + iSenderDisplayText = 0; + iSenderDisplayText = aText.Alloc(); + } + +#ifdef RD_VOIP_REL_2_2 +EXPORT_C void CFindItemMenu::SetMenuItemVisibility( + CFindItemMenu::TMenuItem aItem, + TBool aVisible ) + { + if ( aVisible ) + { + // iMenuItemFlags, 0 = visible + iMenuItemFlags &= ~(TInt)aItem; + } + else + { + // iMenuItemFlags, 1 = not allowed + iMenuItemFlags |= (TInt)aItem; + } + } +#else +EXPORT_C void CFindItemMenu::SetMenuItemVisibility( + CFindItemMenu::TMenuItem /*aItem*/, + TBool /*aVisible*/ ) + { + } +#endif // RD_VOIP_REL_2_2 +CCommonUiRepositoryWatcher* CCommonUiRepositoryWatcher::NewL( + const TUid aUid, + const TUint32 aKey, + CCenRepNotifyHandler::TCenRepKeyType aKeyType, + TCallBack aCallBack, + CRepository* aRepository ) + { + CCommonUiRepositoryWatcher* self = + new(ELeave) CCommonUiRepositoryWatcher( + aUid, aKey, aCallBack, aRepository ); + + CleanupStack::PushL( self ); + self->ConstructL( aKeyType ); + CleanupStack::Pop( self ); + + return self; + } + +CCommonUiRepositoryWatcher::~CCommonUiRepositoryWatcher() + { + if ( iNotifyHandler ) + { + iNotifyHandler->StopListening(); + } + delete iNotifyHandler; + } + +CCommonUiRepositoryWatcher::CCommonUiRepositoryWatcher( + const TUid aUid, + const TUint32 aKey, + TCallBack aCallBack, + CRepository* aRepository ) + : iUid( aUid ), + iKey( aKey ), + iCallBack( aCallBack ), + iRepository( aRepository ) + { + } + +void CCommonUiRepositoryWatcher::ConstructL( + CCenRepNotifyHandler::TCenRepKeyType aKeyType ) + { + iNotifyHandler = + CCenRepNotifyHandler::NewL( *this, *iRepository, aKeyType, iKey ); + iNotifyHandler->StartListeningL(); + } + +void CCommonUiRepositoryWatcher::ConstructL() + { + iNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iRepository ); + iNotifyHandler->StartListeningL(); + } + +TUint32 CCommonUiRepositoryWatcher::ChangedKey() + { + return iChangedKey; + } + +void CCommonUiRepositoryWatcher::HandleNotifyInt( + TUint32 aKey, + TInt aNewValue ) + { +#ifdef _DEBUG + RDebug::Print(_L("CCommonUiRepositoryWatcher::HandleNotifyInt aKey=%d, aNewValue=%d"), aKey, aNewValue); +#endif + (void)aNewValue; + iChangedKey = aKey; + iCallBack.CallBack(); + iChangedKey = NCentralRepositoryConstants::KInvalidNotificationId; + } + +void CCommonUiRepositoryWatcher::HandleNotifyError( + TUint32 /*aKey*/, + TInt /*aError*/, + CCenRepNotifyHandler* /*aHandler*/ ) + { + } + + +EXPORT_C TInt MPBAiwNotify::HandleNotifyL(TInt /*aCmdId*/, TInt aEventId, + CAiwGenericParamList& aEventParamList, + const CAiwGenericParamList& /*aInParamList*/) + { + if (aEventId == KAiwEventError) + { + if (aEventParamList.Count() > 0) + { + TInt32 err = aEventParamList[0].Value().AsTInt32(); + User::Leave(err); + } + } + return KErrNone; + } + +// End of File