diff -r 000000000000 -r 8466d47a6819 emailuis/emailui/src/FreestyleEmailUiUtilities.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emailuis/emailui/src/FreestyleEmailUiUtilities.cpp Thu Dec 17 08:39:21 2009 +0200 @@ -0,0 +1,3697 @@ +/* +* Copyright (c) 2007 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 : General utilities for FS Email UI. +* +*/ + + +#include "emailtrace.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // RApaLsSession + +#ifndef FF_CMAIL_INTEGRATION +#include +#endif // FF_CMAIL_INTEGRATION + +// +//#ifdef __SERIES60_32__ +// +#include +#include +#include +#include + +// +//#else +//#include +//#include +//#endif +// + +#include +#include +#include +#include +#include +#include // for clipboard copy +#include +#include + +#include // CSendUi +#include // P&S key for email notification +#include // RPoperty +#include // Constants for sendui +#include // CMessageData +#include +#include // offline mode keys +#include + + +// Removed DISABLE_DEFAULT_EMAIL +//#ifndef DISABLE_DEFAULT_EMAIL +//#include +//#include +//#endif +// + +// +#include "cfsccontactactionservice.h" +#include "cfsccontactactionmenu.h" +#include "cfsccontactactionmenuitem.h" +#include "mfsccontactactionmenumodel.h" +// + +#include +#include + +// +#include "CFSMailCommon.h" +#include "CFSMailClient.h" +#include "CFSMailBox.h" +#include "CFSMailMessage.h" +#include "cesmricalviewer.h" +// + +#include "FreestyleEmailUiUtilities.h" +#include "FreestyleEmailUiConstants.h" +#include "FreestyleEmailUiLiterals.h" +#include "FreestyleEmailUiAppui.h" +#include "FSDelayedLoader.h" +#include "FSEmail.pan" + +// CONSTANTS +_LIT( KFsEmailIconFileName, "FreestyleEmailUi.mif" ); +_LIT( KFsEmailTempDirName, "temp\\" ); +static const TUint KSecondSeparator = 1; +_LIT( KTimeFormatBefore, "%-B" ); +_LIT( KTimeFormatAfter, "%+B" ); +_LIT( KTimeFormatHour, "%J" ); +_LIT( KTimeFormatMinutes, "%T" ); +_LIT( KTimeFormatSpace, " "); + +// MIME types +_LIT( KPdfMimeString, "application/pdf" ); +_LIT( KRtfMimeString, "application/rtf" ); +_LIT( KDocMimeString, "application/msword" ); +_LIT( KDocMimeString2, "application/vnd.ms-word" ); +_LIT( KPptMimeString, "application/vnd.ms-powerpoint" ); +_LIT( KXlsMimeString, "application/vnd.ms-excel" ); +_LIT( KImageMimeString, "image/" ); +_LIT( KHtmlMimeString, "text/html" ); +_LIT( KPlainTextMimeString, "text/plain" ); +_LIT( KVCalMimeString, "text/x-vcalendar" ); +_LIT( KMessageMimeString, "message/rfc822" ); + +// File name extensions +_LIT( KDocFileExtension, ".doc" ); +_LIT( KRtfFileExtension, ".rtf" ); +_LIT( KPptFileExtension, ".ppt" ); +_LIT( KXlsFileExtension, ".xls" ); +_LIT( KPdfFileExtension, ".pdf" ); +_LIT( KJpgFileExtension, ".jpg" ); +_LIT( KJpegFileExtension, ".jpeg" ); +_LIT( KJpgeFileExtension, ".jpge" ); +_LIT( KPngFileExtension, ".png" ); +_LIT( KGifFileExtension, ".gif" ); +_LIT( KBmpFileExtension, ".bmp" ); +_LIT( KHtmlFileExtension, ".html" ); +_LIT( KHtmFileExtension, ".htm" ); +_LIT( KTxtFileExtension, ".txt" ); +_LIT( KVCalFileExtension, ".vcs" ); +_LIT( KEmailFileExtension, ".eml" ); + +// If the fetched body size (in bytes) is more than these limits, +// a wait note is used when opening, replying, or forwarding the message +static const TInt KLargePlainTextSizeLimit = 20000; +static const TInt KLargeHtmlTextSizeLimit = 50000; + +// id is different in cmail +const TUid KFSMailServerUid = { 0x2001F40A }; +_LIT( KFSMailServerExe, "\\sys\\bin\\fsmailserver.exe" ); +// + +// Define static members +CAknGlobalNote* TFsEmailUiUtility::iGlobalWaitNote = NULL; +// +CESMRIcalViewer* TFsEmailUiUtility::iMrViewer = NULL; +TFsEmailUiUtility::CMrViewerEmptyCallback* TFsEmailUiUtility::iMrViewerCallback = NULL; +CAknWaitDialog* TFsEmailUiUtility::iOpeningWaitNote = NULL; +// + +// FUNCTION DEFINITIONS +void TFsEmailUiUtility::LaunchHelpL( const TDesC& aContext ) + { + FUNC_LOG; + CArrayFix< TCoeHelpContext >* cntx = new( ELeave ) CArrayFixFlat< TCoeHelpContext >( 1 ); + CleanupStack::PushL( cntx ); + cntx->AppendL( TCoeHelpContext( KFSEmailUiUid, aContext ) ); + CleanupStack::Pop( cntx ); + HlpLauncher::LaunchHelpApplicationL( CEikonEnv::Static()->WsSession(), cntx ); + } + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CFsEmailFileHandleShutter* CFsEmailFileHandleShutter::NewL( + CDocumentHandler& aDocumentHandler ) + { + FUNC_LOG; + CFsEmailFileHandleShutter* self = new (ELeave) CFsEmailFileHandleShutter; + CleanupStack::PushL( self ); + self->ConstructL( aDocumentHandler ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// Destructor. File handle is closed, if it has been left open. +// --------------------------------------------------------------------------- +// +CFsEmailFileHandleShutter::~CFsEmailFileHandleShutter() + { + FUNC_LOG; + if (iHandleOpen) + { + iFileHandle.Close(); + } + } + +// --------------------------------------------------------------------------- +// Stores the give file handle. +// --------------------------------------------------------------------------- +// +void CFsEmailFileHandleShutter::SetFile( RFile aFile ) + { + FUNC_LOG; + // Close previously set handle, if necessary. + if ( iHandleOpen ) + { + iFileHandle.Close(); + } + + iFileHandle = aFile; + iHandleOpen = ETrue; + } + +// --------------------------------------------------------------------------- +// Handles the exit of embedded viewer application. +// --------------------------------------------------------------------------- +// +void CFsEmailFileHandleShutter::HandleServerAppExit( TInt aReason ) + { + FUNC_LOG; + if (iHandleOpen) + { + // Close open file handle. + iFileHandle.Close(); + iHandleOpen = EFalse; + } + MAknServerAppExitObserver::HandleServerAppExit( aReason ); + + // Clear the temp directory since the closed file might have been copied there + TFsEmailUiUtility::EraseTempDir(); + } + +CFsEmailFileHandleShutter::CFsEmailFileHandleShutter() + : iHandleOpen(EFalse) + { + FUNC_LOG; + } + +void CFsEmailFileHandleShutter::ConstructL( + CDocumentHandler& aDocumentHandler ) + { + FUNC_LOG; + aDocumentHandler.SetExitObserver(this); + } + +// --------------------------------------------------------------------------- +// Clean up any static variables of the class +// --------------------------------------------------------------------------- +// +void TFsEmailUiUtility::DeleteStaticData() + { + FUNC_LOG; + delete iGlobalWaitNote; + iGlobalWaitNote = NULL; + + // + delete iMrViewer; + iMrViewer = NULL; + + delete iMrViewerCallback; + iMrViewerCallback = NULL; + // + } + +// --------------------------------------------------------------------------- +// GetMceDefaultMailboxL +// Returrn the default mailbox. If one the FS account is set as default return +// it else return the first FS account. If no FS account then returns NULL. +// --------------------------------------------------------------------------- +// +CFSMailBox* TFsEmailUiUtility::GetMceDefaultMailboxL( CFSMailClient& aClient, CMsvSession& aMsvSession ) + { + FUNC_LOG; +// S60 UID update + const TUid KUidMsgValTypeFsMtmVal = { 0x2001F406 }; +// S60 UID update + TFSMailMsgId id; + TBool getFirstInList = EFalse; + + CMsvEntry* root = CMsvEntry::NewL( aMsvSession, KMsvRootIndexEntryId, + TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ) ); + CleanupStack::PushL( root ); + +// Removed DISABLE_DEFAULT_EMAIL +/*#ifndef DISABLE_DEFAULT_EMAIL + TInt entryId; + TInt rval; + CRepository* repository = NULL; + TRAPD( ret, repository = CRepository::NewL(KCRUidSelectableDefaultEmailSettings) ); + if ( ret == KErrNone ) + { + CleanupStack::PushL( repository ); + rval = repository->Get( KSelectableDefaultMailAccount, entryId ); + if( rval == KErrNone && entryId != -1 ) + { + root->SetEntryL( entryId ); + if ( root->Entry().iMtm == KUidMsgValTypeFsMtmVal ) + { + // One of The FS is default e-mail account. + id = TFSMailMsgId( root->Entry().iMtmData1, root->Entry().iMtmData2 ); + } + else + { + // If FS is not default then get the first one in the list + getFirstInList = ETrue; + } + } + else + { + // If no mail box is set as default, then get the first one in the list + getFirstInList = ETrue; + } + CleanupStack::PopAndDestroy( repository ); + } + else + { + // If Failed to create repository, then get the first one in the list + getFirstInList = ETrue; + } +#else*/ + // If the SDK doesn't have default mail box concept. + getFirstInList = ETrue; +//#endif +// + if( getFirstInList ) + { + // Get the list and return the first one. + root->SetEntryL( KMsvRootIndexEntryId ); + CMsvEntrySelection* childSelection = root->ChildrenWithMtmL( + KUidMsgValTypeFsMtmVal ); + CleanupStack::PushL( childSelection ); + + if ( childSelection->Count() > 0) + { + root->SetEntryL( childSelection->At( 0 ) ); + id = TFSMailMsgId( root->Entry().iMtmData1, root->Entry().iMtmData2 ); + } + else + { + // No FS Mail box. + //id.SetNullId(); + } + CleanupStack::PopAndDestroy( childSelection ); + } + CleanupStack::PopAndDestroy( root ); + if( id.IsNullId() ) + { + // If No FS Mailbox then return NULL. + return NULL; + } + else + { + CFSMailBox* mailbox = aClient.GetMailBoxByUidL( id ); + return mailbox; + } + } + +// --------------------------------------------------------------------------- +// GetMailboxForMtmIdL +// Return the mailbox based on mtm id. If there is an mtm account with aMtmId +// return the mail box of it else returns NULL +// --------------------------------------------------------------------------- +// +CFSMailBox* TFsEmailUiUtility::GetMailboxForMtmIdL( CFSMailClient& aClient, + CMsvSession& aMsvSession, TMsvId aMtmId ) + { + FUNC_LOG; +// S60 UID update + const TUid KUidMsgValTypeFsMtmVal = { 0x2001F406 }; +// S60 UID update + CMsvEntry* accountEntry = NULL; + TRAPD(err, accountEntry = CMsvEntry::NewL( aMsvSession, aMtmId, + TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ))); + if(err == KErrNotFound || err == KErrNoMemory || + accountEntry->Entry().iMtm != KUidMsgValTypeFsMtmVal) + { + // This Mtm Id is not found or the found entry is not FS entry + return NULL; + } + CleanupStack::PushL( accountEntry ); + TFSMailMsgId id = TFSMailMsgId( accountEntry->Entry().MtmData1(), + accountEntry->Entry().MtmData2() ); + CleanupStack::PopAndDestroy( accountEntry ); + CFSMailBox* mailbox = aClient.GetMailBoxByUidL( id ); + return mailbox; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::IsRemoteLookupSupported +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::IsRemoteLookupSupported( CFSMailBox& aMailBox ) + { + FUNC_LOG; + + TBool r = aMailBox.HasCapability( EFSMBoxCapaSupportsRCL ); + + return r; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowConfirmationQuery +// ----------------------------------------------------------------------------- +TInt TFsEmailUiUtility::ShowConfirmationQueryL( TInt aResourceStringId, + const TDesC& aResourceParameter ) + { + FUNC_LOG; + CFSEmailUiCallDialog* queryNote = new ( ELeave ) CFSEmailUiCallDialog(); + CleanupStack::PushL( queryNote ); + HBufC* resourceString = NULL; + if ( aResourceParameter != KNullDesC ) + { + resourceString = StringLoader::LoadLC( aResourceStringId, + aResourceParameter ); + } + else + { + resourceString = StringLoader::LoadLC( aResourceStringId ); + } + queryNote->SetPromptL( *resourceString ); + CleanupStack::PopAndDestroy( resourceString ); + CleanupStack::Pop( queryNote ); + return queryNote->ExecuteLD( R_FSEMAIL_QUERY_DIALOG ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowConfirmationQuery +// ----------------------------------------------------------------------------- +TInt TFsEmailUiUtility::ShowConfirmationQueryL( const TDesC& aPromptText ) + { + FUNC_LOG; + CFSEmailUiCallDialog* queryNote = new ( ELeave ) CFSEmailUiCallDialog(); + CleanupStack::PushL( queryNote ); + queryNote->SetPromptL( aPromptText ); + CleanupStack::Pop( queryNote ); + return queryNote->ExecuteLD( R_FSEMAIL_QUERY_DIALOG ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowErrorNoteL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::ShowErrorNoteL( TInt aResourceStringId, TBool aWaitingDialog ) + { + FUNC_LOG; + HBufC* errMessage = StringLoader::LoadLC( aResourceStringId ); + CAknErrorNote* note = new (ELeave) CAknErrorNote( aWaitingDialog ); + note->ExecuteLD( *errMessage ); + CleanupStack::PopAndDestroy( errMessage ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowInfoNoteL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::ShowInfoNoteL( TInt aResourceStringId, TBool aWaitingDialog ) + { + FUNC_LOG; + HBufC* message = StringLoader::LoadLC( aResourceStringId ); + CAknInformationNote* note = new (ELeave) CAknInformationNote( aWaitingDialog ); + note->ExecuteLD( *message ); + CleanupStack::PopAndDestroy( message ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowGlobalErrorNoteL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::ShowGlobalErrorNoteL( TInt aResourceStringId ) + { + FUNC_LOG; + HBufC* noteText = StringLoader::LoadLC( aResourceStringId ); + CAknGlobalNote* globalNote = CAknGlobalNote::NewLC(); + globalNote->ShowNoteL( EAknGlobalErrorNote, *noteText ); + CleanupStack::PopAndDestroy( globalNote ); + CleanupStack::PopAndDestroy( noteText ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowGlobalInfoNoteL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::ShowGlobalInfoNoteL( TInt aResourceStringId ) + { + FUNC_LOG; + HBufC* noteText = StringLoader::LoadLC( aResourceStringId ); + CAknGlobalNote* globalNote = CAknGlobalNote::NewLC(); + globalNote->ShowNoteL( EAknGlobalInformationNote, *noteText ); + CleanupStack::PopAndDestroy( globalNote ); + CleanupStack::PopAndDestroy( noteText ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowWaitNoteL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::ShowWaitNoteL( CAknWaitDialog*& aDialog, TInt aTextResourceId, + TBool aAllowCancel, TBool aVisibilityDelayOff /*= EFalse*/ ) + { + FUNC_LOG; + if ( !aDialog ) + { + aDialog = new (ELeave) CAknWaitDialog( + reinterpret_cast(&aDialog), aVisibilityDelayOff ); + } + + if ( aAllowCancel ) + { + aDialog->PrepareLC( R_FSE_WAIT_DIALOG ); + } + else + { + aDialog->PrepareLC( R_FSE_WAIT_DIALOG_NO_CANCEL ); + } + + HBufC* noteText = StringLoader::LoadLC( aTextResourceId ); + aDialog->SetTextL( *noteText ); + CleanupStack::PopAndDestroy( noteText ); + + aDialog->RunLD(); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowGlobalWaitNoteLC +// ----------------------------------------------------------------------------- +TInt TFsEmailUiUtility::ShowGlobalWaitNoteLC( TInt aTextResourceId ) + { + FUNC_LOG; + if ( !iGlobalWaitNote ) + { + iGlobalWaitNote = CAknGlobalNote::NewL(); + iGlobalWaitNote->SetSoftkeys( R_AVKON_SOFTKEYS_EMPTY ); + } + + HBufC* noteText = StringLoader::LoadLC( aTextResourceId ); + TInt waitNoteId = iGlobalWaitNote->ShowNoteL( EAknGlobalWaitNote, *noteText ); + CleanupStack::PopAndDestroy( noteText ); + + TCleanupItem closeNoteItem( CloseGlobalWaitNote, + reinterpret_cast(waitNoteId) ); + CleanupStack::PushL( closeNoteItem ); + + return waitNoteId; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CloseGlobalWaitNote +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::CloseGlobalWaitNote( TAny* aNoteId ) + { + FUNC_LOG; + if ( iGlobalWaitNote ) + { + TInt noteId = reinterpret_cast( aNoteId ); + TRAP_IGNORE( iGlobalWaitNote->CancelNoteL( noteId ) ); + } + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowSelectFileDialogL +// ----------------------------------------------------------------------------- +// +TBool TFsEmailUiUtility::ShowSelectFileDialogL( TDes& aFileName ) + { + FUNC_LOG; + return ShowFileDialogL( ECFDDialogTypeSelect, aFileName ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowSaveFolderDialogL +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::ShowSaveFolderDialogL( TDes& aFileName ) + { + FUNC_LOG; + return ShowFileDialogL( ECFDDialogTypeSave, aFileName ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowSaveFolderDialogL +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::ShowFileDialogL( TInt aType, TDes& aFileName ) + { + FUNC_LOG; + TInt retVal = EFalse; + + TInt allDrives = + AknCommonDialogsDynMem::EMemoryTypePhone | + AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage | + AknCommonDialogsDynMem::EMemoryTypeMMCExternal | + AknCommonDialogsDynMem::EMemoryTypeRemote; + + if ( aType == ECFDDialogTypeSelect ) + { + retVal = AknCommonDialogsDynMem::RunSelectDlgLD( allDrives, aFileName, 0 ); + } + else if ( aType == ECFDDialogTypeSave ) + { + // We can't use the SaveDlg of CommonDialogs because it launches also the file name query + // which we do not want. Instead, we use move-to-folder dialog with the title and softkeys + // of the save dialog. + retVal = AknCommonDialogsDynMem::RunMoveDlgLD( allDrives, aFileName, + R_CFD_DEFAULT_SAVE_MEMORY_SELECTION, R_CFD_DEFAULT_SAVE_FILE_SELECTION ); + } + else + { + __ASSERT_DEBUG( EFalse, Panic(EFSEmailUiUnexpectedValue) ); + } + + return retVal; + } + + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::OkToSaveFileL +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::OkToSaveFileL( const TDesC& aFilePath, CFSMailMessagePart& aAttachmentPart ) + { + FUNC_LOG; + TBool ret( ETrue ); + TDesC& name = aAttachmentPart.AttachmentNameL(); + HBufC* realFilePath = HBufC::NewLC( aFilePath.Length() + name.Length() ); + realFilePath->Des().Append( aFilePath); + realFilePath->Des().Append( name); + if ( BaflUtils::FileExists( CEikonEnv::Static()->FsSession(), *realFilePath ) ) + { + if ( !TFsEmailUiUtility::ShowConfirmationQueryL( R_FREESTYLE_EMAIL_UI_OVERWRITE_QUERY, name ) ) + { + ret = EFalse; + } + } + CleanupStack::PopAndDestroy( realFilePath ); + return ret; + } + +// ----------------------------------------------------------------------------- +// +// TFsEmailUiUtility::ShowFileSavedToFolderNoteL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::ShowFilesSavedToFolderNoteL( TInt aCount ) + { + FUNC_LOG; + CAknGlobalNote* globalNote = CAknGlobalNote::NewLC(); + if ( aCount == 1 ) + { + HBufC* noteText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_ONE_ATTACHMENT_SAVED ); + globalNote->ShowNoteL( EAknGlobalInformationNote, *noteText ); + CleanupStack::PopAndDestroy( noteText ); + } + else if ( aCount > 1 ) + { + HBufC* noteText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_MULTIPLE_ATTACHMENT_SAVED, aCount ); + globalNote->ShowNoteL( EAknGlobalInformationNote, *noteText ); + CleanupStack::PopAndDestroy( noteText ); + } + CleanupStack::PopAndDestroy( globalNote ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::OpenFileL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::OpenFileL( RFile& aFileToOpen, TBool aAllowSave ) + { + FUNC_LOG; + TDataType emptyDataType; + OpenFileL( aFileToOpen, emptyDataType,aAllowSave ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::OpenFileL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::OpenFileL( RFile& aFileToOpen, TDataType& aDataType, TBool aAllowSave ) + { + FUNC_LOG; + CFreestyleEmailUiAppUi* appUi = (CFreestyleEmailUiAppUi*)CCoeEnv::Static()->AppUi(); + + // Set file handle shutter to close the file handle after the embedded + // viewer application exits. + appUi->FileHandleShutter().SetFile( aFileToOpen ); + + CDocumentHandler& docHandler = appUi->DocumentHandler(); + CAiwGenericParamList& paramList = docHandler.InParamListL(); + + // Set allow save to parameter. + if ( aAllowSave ) + { + TAiwVariant allowSaveVariant( ETrue ); + TAiwGenericParam genericParamAllowSave( EGenericParamAllowSave, + allowSaveVariant ); + paramList.AppendL( genericParamAllowSave ); + } + + TInt res = KErrNone; + TRAPD( err, res = docHandler.OpenFileEmbeddedL( aFileToOpen, aDataType, paramList ) ); + + // Try again with an empty data type if opening using the given data type fails + if ( err != KErrNone || res != KErrNone ) + { + TDataType emptyType; + + // Open file embedded + TRAP( err, res = docHandler.OpenFileEmbeddedL( aFileToOpen, emptyType, paramList ) ); + + // Show an error note if opening the file still didn't succeed + // Ensure also that the file handle got closed. + if ( err != KErrNone || res != KErrNone ) + { + ShowErrorNoteL( R_FREESTYLE_EMAIL_INFO_NOTE_UNABLE_TO_OPEN, EFalse ); + appUi->FileHandleShutter().HandleServerAppExit( KErrCancel ); + } + } + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::OpenAttachmentL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::OpenAttachmentL( const TPartData& aAttachmentPart ) + { + FUNC_LOG; + CFreestyleEmailUiAppUi* appUi = (CFreestyleEmailUiAppUi*)CCoeEnv::Static()->AppUi(); + CFSMailMessage* mailMessage = appUi->GetMailClient()->GetMessageByUidL( + aAttachmentPart.iMailBoxId, aAttachmentPart.iFolderId, + aAttachmentPart.iMessageId, EFSMsgDataStructure ); + + CleanupStack::PushL( mailMessage ); + CFSMailMessagePart* messagePart = mailMessage->ChildPartL( + aAttachmentPart.iMessagePartId ); + CleanupStack::PushL( messagePart ); + + OpenAttachmentL( *messagePart ); + + CleanupStack::PopAndDestroy( messagePart ); + CleanupStack::PopAndDestroy( mailMessage ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::OpenAttachmentL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::OpenAttachmentL( CFSMailMessagePart& aAttachmentPart, + TBool aAllowSave /*= ETrue*/) + { + FUNC_LOG; + const TDesC& attName = aAttachmentPart.AttachmentNameL(); + const TDesC* mimeType16 = &aAttachmentPart.GetContentType(); + TFileType fileType = GetFileType( attName, *mimeType16 ); + + // Check if attachment is actually an embedded message object. In that case we try to + // open it using mail viewer. + TBool openedAsMessage = EFalse; + if ( fileType == EMessageType ) + { + CFreestyleEmailUiAppUi* appUi = + static_cast( CCoeEnv::Static()->AppUi() ); + + // First, try to get the message object directly from mail client using the UIDs. + CFSMailMessage* message = NULL; + TRAP_IGNORE( message = appUi->GetMailClient()->GetMessageByUidL( + aAttachmentPart.GetMailBoxId(), + aAttachmentPart.GetFolderId(), + aAttachmentPart.GetPartId(), + EFSMsgDataEnvelope ) ); + + // If we still have no message, then try to convert the attachment file to message object (Activesync case). + if ( !message ) + { + // This takes some time so we show a wait dialog. + if ( iOpeningWaitNote ) + { + iOpeningWaitNote->ProcessFinishedL(); + iOpeningWaitNote = NULL; + } + ShowWaitNoteL( iOpeningWaitNote, R_FSE_WAIT_OPENING_TEXT, EFalse, ETrue ); + + RFile attFile = aAttachmentPart.GetContentFileL(); + CleanupClosePushL( attFile ); + CFSMailBox* mailbox = appUi->GetMailClient()->GetMailBoxByUidL( aAttachmentPart.GetMailBoxId() ); + CleanupStack::PushL( mailbox ); + TRAP_IGNORE( message = mailbox->CreateMessageFromFileL( attFile ) ); + CleanupStack::PopAndDestroy( mailbox ); + CleanupStack::PopAndDestroy( &attFile ); + + iOpeningWaitNote->ProcessFinishedL(); + } + + // Open message to viewer if we got it. Otherwise continue with the standard file opening logic. + if ( message ) + { + // Check that the embedded message has text body part or html body part. + // Otherwise we cannot display it viewer and needs to be handled as a normal attachment. + + CFSMailMessagePart* htmlPart = message->HtmlBodyPartL(); + CFSMailMessagePart* textPart = message->PlainTextBodyPartL(); + + if ( htmlPart || textPart ) + { + THtmlViewerActivationData htmlData; + htmlData.iActivationDataType = THtmlViewerActivationData::EmbeddedEmailMessage; + htmlData.iMailBoxId = aAttachmentPart.GetMailBoxId(); + htmlData.iFolderId = aAttachmentPart.GetFolderId(); + htmlData.iMessageId = aAttachmentPart.GetPartId(); + // ownership of message gets transfered to html viewer. + htmlData.iEmbeddedMessage = message; + htmlData.iEmbeddedMessageMode = ETrue; + TPckgBuf pckgData( htmlData ); + + appUi->EnterFsEmailViewL( HtmlViewerId, KStartViewerWithEmbeddedMsgPtr, pckgData ); + openedAsMessage = ETrue; + } + else + { + //delete message object owned by us. + delete message; + } + + if( htmlPart ) + { + delete htmlPart; + } + if( textPart ) + { + delete textPart; + } + + } + } + + // Normal attachment file opening + if ( !openedAsMessage ) + { + RFile attachmentFile; + + // Get the temp file provided by plugin + RFile pluginTempFile = aAttachmentPart.GetContentFileL(); + CleanupClosePushL( pluginTempFile ); + + // Check if the temp file has diffrent file extension than the attachment name. + TFileName tempFileName; + pluginTempFile.Name( tempFileName ); + const TDesC& attName = aAttachmentPart.AttachmentNameL(); + if ( !DoFileExtensionsMatchL( tempFileName, attName ) ) + { + // Make a new temporary copy of the attachment file if the temp file + // provided by the plugin does not have a proper file extension. + // This is needed because some applications may not + // allow opening files with improper file extension. + attachmentFile = CopyFileToTempDirL( pluginTempFile, attName ); + CleanupStack::PopAndDestroy( &pluginTempFile ); + } + else + { + // Otherwise we may use the temp file provided by plugin directly + attachmentFile = pluginTempFile; + CleanupStack::Pop( &pluginTempFile ); + } + CleanupClosePushL( attachmentFile ); + + // Use given MIME type if present + TDataType dataType; + const TDesC* mimeType16 = &aAttachmentPart.GetContentType(); + if ( mimeType16->Length() ) + { + // V-calendar attachments sent from MS Outlook seem to have wrong MIME type. Work around + // this by overriding the MIME type in case the file can be identified to be VCal object + if ( GetFileType( attName, *mimeType16 ) == EVCalType ) + { + mimeType16 = &KVCalMimeString; + } + + // The MIME type must be converted to 8 bit buffer. Just assume it's ASCII data + // and forget the upper bytes. + HBufC8* mimeType8 = HBufC8::NewLC( mimeType16->Length() ); + mimeType8->Des().Append( *mimeType16 ); + //cut extra data from MIME string + TInt pos = mimeType8->Locate( ';' ); + if ( pos >= 0 ) + { + mimeType8->Des().SetLength(pos); + } + dataType = TDataType( *mimeType8 ); + CleanupStack::PopAndDestroy( mimeType8 ); + } + + CleanupStack::Pop( &attachmentFile ); // next function takes ownershp of the handle + OpenFileL( attachmentFile, dataType, aAllowSave ); + } + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::SetMessageFollowupFlagL +// ----------------------------------------------------------------------------- +TFollowUpNewState TFsEmailUiUtility::SetMessageFollowupFlagL( CFSMailMessage& aMsg, + TBool aShowFlagCompleted ) + { + FUNC_LOG; + TFollowUpNewState newFollowUpState = EFollowUpNoChanges; + if ( TFsEmailUiUtility::RunFollowUpListDialogL( newFollowUpState, aShowFlagCompleted ) ) + { + SetMessageFollowupStateL( aMsg, newFollowUpState ); + } + return newFollowUpState; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::SetssageFollowupStateL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::SetMessageFollowupStateL( CFSMailMessage& aMsg, + TFollowUpNewState aNewFollowUpState ) + { + FUNC_LOG; + switch ( aNewFollowUpState ) + { + case EFollowUp: + { + aMsg.SetFlag( EFSMsgFlag_FollowUp ); + aMsg.ResetFlag( EFSMsgFlag_FollowUpComplete ); + } + break; + case EFollowUpComplete: + { + aMsg.SetFlag( EFSMsgFlag_FollowUpComplete ); + aMsg.ResetFlag( EFSMsgFlag_FollowUp ); + } + break; + case EFollowUpClear: + { + aMsg.ResetFlag( EFSMsgFlag_FollowUp | EFSMsgFlag_FollowUpComplete ); + } + break; + } + aMsg.SaveMessageL(); // Save flag status + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::RunFollowUpListDialogL +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::RunFollowUpListDialogL( TFollowUpNewState& aSelectedOption, + TBool aShowFlagCompleted ) + { + FUNC_LOG; + aSelectedOption = EFollowUpNoChanges; + + CDesCArrayFlat* array = new (ELeave) CDesCArrayFlat( 2 ); + CleanupStack::PushL( array ); + + // Add follow up text + _LIT( KListItemIcon0, "0\t" ); + + // aShowFlagCompleted is false when we are in the editor/composer view + TInt followUpResId = + ( aShowFlagCompleted ? R_FREESTYLE_EMAIL_UI_FLAG_FOLLOW_UP : + R_NCS_FLAG_FOLLOW_UP ); + + HBufC* followUp = StringLoader::LoadLC( followUpResId ); + + HBufC* followUpText = HBufC::NewLC( KListItemIcon0().Length() + followUp->Length() ); + followUpText->Des().Append( KListItemIcon0 ); + followUpText->Des().Append( *followUp ); + array->AppendL( *followUpText ); + CleanupStack::PopAndDestroy( 2, followUp ); + + // Add flag complete text if requested + if ( aShowFlagCompleted ) + { + _LIT( KListItemIcon1, "1\t" ); + HBufC* completeFlag = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_FLAG_COMPLETE ); + HBufC* completeFlagText = HBufC::NewLC( KListItemIcon1().Length() + completeFlag->Length() ); + completeFlagText->Des().Append( KListItemIcon1 ); + completeFlagText->Des().Append( *completeFlag ); + array->AppendL( *completeFlagText ); + CleanupStack::PopAndDestroy( 2, completeFlag ); + } + + // Add clear flag text + _LIT( KListItemNoIcon, "\t" ); + + // aShowFlagCompleted is false when we are in the editor/composer view + TInt clearResId = ( aShowFlagCompleted ? R_FREESTYLE_EMAIL_UI_FLAG_CLEAR : + R_NCS_FLAG_CLEAR ); + + HBufC* clearFlag = StringLoader::LoadLC( clearResId ); + HBufC* clearFlagText = HBufC::NewLC( KListItemNoIcon().Length() + clearFlag->Length() ); + clearFlagText->Des().Append( KListItemNoIcon ); + clearFlagText->Des().Append( *clearFlag ); + array->AppendL( *clearFlagText ); + CleanupStack::PopAndDestroy( 2, clearFlag ); + + TInt selectedOption; + CAknListQueryDialog* dlg = new ( ELeave ) CAknListQueryDialog( &selectedOption ); + + // aShowFlagCompleted is false when we are in the editor/composer view + TInt dlgResId = ( aShowFlagCompleted ? R_MAIL_FLAG_QUERY_DIALOG : + R_NCS_MAIL_FLAG_QUERY_DIALOG ); + + dlg->PrepareLC( dlgResId ); + + //Create icon array from correct icons + TFileName iconFileName; + GetFullIconFileNameL( iconFileName ); + + CArrayPtr* icons = new (ELeave) CAknIconArray( 2 ); + CleanupStack::PushL(icons); + CFbsBitmap* iconBitmap; + CFbsBitmap* iconMaskBitmap; + TSize defaultIconSize(20,20); + +// icons changed + // Flag icon "followup" + AknsUtils::CreateColorIconLC( + AknsUtils::SkinInstance(), + KAknsIIDNone, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG7, + iconBitmap, + iconMaskBitmap, + iconFileName, + EMbmFreestyleemailuiQgn_indi_cmail_viewer_follow_up, + EMbmFreestyleemailuiQgn_indi_cmail_viewer_follow_up_mask, + KRgbBlack ); + AknIconUtils::SetSize(iconBitmap, defaultIconSize ); + AknIconUtils::SetSize(iconMaskBitmap, defaultIconSize); + CGulIcon* flagIcon = CGulIcon::NewL(iconBitmap, iconMaskBitmap); + CleanupStack::Pop( 2, iconBitmap ); + CleanupStack::PushL( flagIcon ); + icons->AppendL( flagIcon ); + CleanupStack::Pop( flagIcon ); + + // Flag icon "completed" + AknsUtils::CreateColorIconLC( + AknsUtils::SkinInstance(), + KAknsIIDNone, + KAknsIIDQsnIconColors, + EAknsCIQsnIconColorsCG7, + iconBitmap, + iconMaskBitmap, + iconFileName, + EMbmFreestyleemailuiQgn_indi_cmail_viewer_follow_up_complete, + EMbmFreestyleemailuiQgn_indi_cmail_viewer_follow_up_complete_mask, + KRgbBlack ); + AknIconUtils::SetSize(iconBitmap, defaultIconSize ); + AknIconUtils::SetSize(iconMaskBitmap, defaultIconSize); + CGulIcon* flagCompleteIcon = CGulIcon::NewL(iconBitmap, iconMaskBitmap); + CleanupStack::Pop( 2, iconBitmap ); + CleanupStack::PushL( flagCompleteIcon ); + icons->AppendL( flagCompleteIcon ); + CleanupStack::Pop( flagCompleteIcon ); +// + + // Run the dialog + dlg->SetItemTextArray( array ); + dlg->SetIconArrayL( icons ); + CleanupStack::Pop( icons ); + dlg->SetOwnershipType( ELbmDoesNotOwnItemArray ); + TBool retVal = dlg->RunLD(); + CleanupStack::PopAndDestroy( array ); + + if ( retVal ) + { + // Convert the returned index to enumeration. This mapping is different depending + // if "flag completed" is shown or not + aSelectedOption = static_cast( selectedOption ); + if ( !aShowFlagCompleted && aSelectedOption == EFollowUpComplete ) + { + aSelectedOption = EFollowUpClear; + } + } + + return retVal; + } + + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ShowCreateMessageQueryL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::ShowCreateMessageQueryL( const TDesC& aAddressData, TBool aSendingToEmail ) + { + FUNC_LOG; + if ( aAddressData.Length() ) // Sending needs address data in any case + { + CSendUi* sendUi = CSendUi::NewLC(); + TSendingCapabilities noCapabilities(0,0,0); + + CArrayFix* showedServicesUidArray = new( ELeave ) CArrayFixFlat(4); + CleanupStack::PushL( showedServicesUidArray ); + + CDesCArrayFlat* array = new ( ELeave ) CDesCArrayFlat( 2 ); + CleanupStack::PushL( array ); + + if( !aSendingToEmail && sendUi->ValidateServiceL( KSenduiMtmSmsUid, noCapabilities ) ) + { + HBufC* textMessage = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_TEXT_MESSAGE ); + array->AppendL( *textMessage ); + CleanupStack::PopAndDestroy( textMessage ); + showedServicesUidArray->AppendL( KSenduiMtmSmsUid ); + } + if( sendUi->ValidateServiceL( KSenduiMtmMmsUid, noCapabilities ) ) + { + HBufC* multimediaMessage = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_MULTIMEDIA_MESSAGE ); + array->AppendL( *multimediaMessage ); + CleanupStack::PopAndDestroy( multimediaMessage ); + showedServicesUidArray->AppendL( KSenduiMtmMmsUid ); + } + if( sendUi->ValidateServiceL( KSenduiMtmAudioMessageUid, noCapabilities ) ) + { + HBufC* voiceMessage = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_VOICE_MESSAGE ); + array->AppendL( *voiceMessage ); + CleanupStack::PopAndDestroy( voiceMessage ); + showedServicesUidArray->AppendL( KSenduiMtmAudioMessageUid ); + } + + TInt selectedOption; + CAknListQueryDialog* dlg = new ( ELeave ) CAknListQueryDialog( &selectedOption ); + dlg->PrepareLC( R_MAIL_VIEWER_CREATE_MESSAGE_DIALOG ); + dlg->SetItemTextArray( array ); + dlg->SetOwnershipType( ELbmDoesNotOwnItemArray ); + if( dlg->RunLD() ) + { + CMessageData* messageData = CMessageData::NewLC(); + messageData->AppendToAddressL( aAddressData ); + // safety check. + if( showedServicesUidArray->Count() > selectedOption ) + { + sendUi->CreateAndSendMessageL( showedServicesUidArray->At( selectedOption ), + messageData ); + } + CleanupStack::PopAndDestroy( messageData ); + } + + CleanupStack::PopAndDestroy( array ); + CleanupStack::PopAndDestroy( showedServicesUidArray ); + CleanupStack::PopAndDestroy( sendUi ); + } + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::GetFileType +// Figures out the file type based on the MIME type and the file name extension. +// The MIME type is used first and if that doesn't help, then the file extension +// is used as backup solution. +// ----------------------------------------------------------------------------- +TFileType TFsEmailUiUtility::GetFileType( const TDesC& aFileName, const TDesC& aMimeType ) + { + FUNC_LOG; + TFileType fileType = EUnidentifiedType; + TPtrC ext = TParsePtrC( aFileName ).Ext(); + + // here we make sure that content type does not have extra parameters + TPtrC mimeType( aMimeType ); + TInt semiColonPos( aMimeType.Locate(';') ); + if( semiColonPos != KErrNotFound ) + { + mimeType.Set( aMimeType.Left(semiColonPos) ); + } + + if ( !mimeType.CompareF(KPdfMimeString) ) + { + fileType = EPdfType; + } + else if ( !mimeType.CompareF(KDocMimeString) || + !mimeType.CompareF(KDocMimeString2) ) + { + fileType = EDocType; + } + else if ( !mimeType.CompareF(KRtfMimeString) ) + { + fileType = ERtfType; + } + else if ( !mimeType.CompareF(KPptMimeString) ) + { + fileType = EPptType; + } + else if ( !mimeType.CompareF(KXlsMimeString) ) + { + fileType = EXlsType; + } + else if ( !mimeType.Left( KImageMimeString().Length() ).CompareF(KImageMimeString) ) + { + fileType = EImageType; + } + else if ( !mimeType.CompareF(KHtmlMimeString) ) + { + fileType = EHtmlType; + } + else if ( !mimeType.CompareF(KPlainTextMimeString) ) + { + fileType = EPlainTextType; + // When v-cal attachment is sent from MS Outlook, it's received with wrong MIME type. + // Following is a workaround for this problem + if ( !ext.CompareF(KVCalFileExtension) ) + { + fileType = EVCalType; + } + } + else if ( !mimeType.CompareF(KVCalMimeString) ) + { + fileType = EVCalType; + } + else if ( !mimeType.CompareF(KMessageMimeString) ) + { + fileType = EMessageType; + } + else + { + // File type couldn't be identified from the MIME type. Use the file extension. + + if ( !ext.CompareF(KDocFileExtension) ) + { + fileType = EDocType; + } + else if ( !ext.CompareF(KRtfFileExtension) ) + { + fileType = ERtfType; + } + else if ( !ext.CompareF(KPptFileExtension) ) + { + fileType = EPptType; + } + else if ( !ext.CompareF(KXlsFileExtension) ) + { + fileType = EXlsType; + } + else if ( !ext.CompareF(KPdfFileExtension) ) + { + fileType = EPdfType; + } + else if ( !ext.CompareF(KHtmlFileExtension) || + !ext.CompareF(KHtmFileExtension) ) + { + fileType = EHtmlType; + } + else if ( !ext.CompareF(KJpgFileExtension) + || !ext.CompareF(KJpgeFileExtension) + || !ext.CompareF(KJpegFileExtension) + || !ext.CompareF(KPngFileExtension) + || !ext.CompareF(KGifFileExtension) + || !ext.CompareF(KBmpFileExtension) ) + { + fileType = EImageType; + } + else if ( !ext.CompareF(KTxtFileExtension) ) + { + fileType = EPlainTextType; + } + else if ( !ext.CompareF(KVCalFileExtension) ) + { + fileType = EVCalType; + } + else if ( !ext.CompareF(KEmailFileExtension) ) + { + fileType = EMessageType; + } + else + { + fileType = EUnidentifiedType; + } + } + + return fileType; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::GetAttachmentIcon +// Funtion for getting correct attachment icon +// ----------------------------------------------------------------------------- +CAlfTexture& TFsEmailUiUtility::GetAttachmentIcon( TFileType aAttachmentType, CFreestyleEmailUiTextureManager& aTextureManager ) + { + FUNC_LOG; + TFSEmailUiTextures textureId = GetAttachmentIconTextureId( aAttachmentType ); + return aTextureManager.TextureByIndex( textureId ); + } + +TFSEmailUiTextures TFsEmailUiUtility::GetAttachmentIconTextureId( TFileType aAttachmentType ) + { + FUNC_LOG; + switch( aAttachmentType ) + { + case EDocType: + return EAttachmentsDocFile; + case ERtfType: + return EAttachmentsRtfFile; + case EPptType: + return EAttachmentsPptFile; + case EXlsType: + return EAttachmentsXls; + case EPdfType: + return EAttachmentsPdfFile; + case EImageType: + return EAttachmentsImageFile; + case EHtmlType: + return EAttachmentsHtmlFile; + case EPlainTextType: + case EVCalType: + case EMessageType: + case EUnidentifiedType: + return EAttachmentsUnknownFile; + default: + ASSERT( EFalse ); + } + return EAttachmentsUnknownFile; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::GetMsgIcon +// Funtion for getting correct msg icon, divides into read and unread icons +// ----------------------------------------------------------------------------- +CAlfTexture& TFsEmailUiUtility::GetMsgIcon( CFSMailMessage* aMsgPtr, + CFreestyleEmailUiTextureManager& aTextureManager ) + { + FUNC_LOG; + TFSEmailUiTextures textureId = GetMsgIconTextureId( aMsgPtr ); + return aTextureManager.TextureByIndex( textureId ); + } + +TFSEmailUiTextures TFsEmailUiUtility::GetMsgIconTextureId( CFSMailMessage* aMsgPtr ) + { + FUNC_LOG; + if ( !aMsgPtr->IsFlagSet( EFSMsgFlag_Read ) ) + { + return GetUnreadMsgIcon( aMsgPtr ); + } + else + { + return GetReadMsgIcon( aMsgPtr ); + } + + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::MoveMessageToDraftsL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::MoveMessageToDraftsL( CFSMailBox& aMailBox, CFSMailMessage& aMsg ) + { + FUNC_LOG; + + // check that msg is not in drafts folder already + TFSMailMsgId draftsFolderId = aMailBox.GetStandardFolderId( EFSDraftsFolder ); + TFSMailMsgId msgFolderId = aMsg.GetFolderId(); + if ( draftsFolderId != msgFolderId ) + { + RArray ids; + ids.Append( aMsg.GetMessageId() ); + aMailBox.MoveMessagesL( ids, msgFolderId, draftsFolderId ); + ids.Reset(); + } + + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::IsMessagePartFullyFetched +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::IsMessagePartFullyFetched( const CFSMailMessagePart& aPart ) + { + FUNC_LOG; + + TFSPartFetchState fetchState = aPart.FetchLoadState(); + TBool isFetched = ( fetchState == EFSFull ); + + return isFetched; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::IsMessageStructureKnown +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::IsMessageStructureKnown( const CFSMailMessagePart& aPart ) + { + FUNC_LOG; + + TFSPartFetchState fetchState = aPart.FetchLoadState(); + TBool isKnown = !( fetchState == EFSEmailStructureUnknown );//( fetchState == EFSFull || fetchState == EFSMessagePartsKnown ); + + return isKnown; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CreatePlainTextPartL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::CreatePlainTextPartL( CFSMailMessage& aMsg, CFSMailMessagePart*& aPart ) + { + FUNC_LOG; + + aPart = aMsg.PlainTextBodyPartL(); + if ( !aPart ) + { + // Do message contain HTML body part + CFSMailMessagePart* htmlPart = aMsg.HtmlBodyPartL(); + if ( htmlPart ) + { + CleanupStack::PushL( htmlPart ); + HBufC* htmlData = HBufC::NewLC( htmlPart->FetchedContentSize() ); + TPtr pointer = htmlData->Des(); + htmlPart->GetContentToBufferL( pointer, 0 ); + + HBufC* txtData = TFsEmailUiUtility::ConvertHtmlToTxtL( *htmlData ); + + CleanupStack::PopAndDestroy( htmlData ); + + CleanupStack::PushL( txtData ); + + // create new message part for body text + TFSMailMsgId id; + aPart = aMsg.NewChildPartL( id, KFSMailContentTypeTextPlain ); + if ( aPart ) + { + aPart->SetContentType( KFSMailContentTypeTextPlain ); + pointer.Set( txtData->Des() ); + aPart->SetContent( pointer ); + aPart->SaveL(); + } + + CleanupStack::PopAndDestroy( txtData ); + CleanupStack::PopAndDestroy( htmlPart ); + } + else + { + // create new message part for body text + TFSMailMsgId id; + aPart = aMsg.NewChildPartL( id, KFSMailContentTypeTextPlain ); + if ( aPart ) + { + aPart->SetContentType( KFSMailContentTypeTextPlain ); + aPart->SaveL(); + } + } + } + + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::IsCompleteOrCancelEvent +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::IsCompleteOrCancelEvent( TFSProgress aEvent ) + { + FUNC_LOG; + return ( TFSProgress::EFSStatus_RequestComplete == aEvent.iProgressStatus || + TFSProgress::EFSStatus_RequestCancelled == aEvent.iProgressStatus ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::HasUnfetchedAttachmentsL +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::HasUnfetchedAttachmentsL( CFSMailMessage& aMsg ) + { + FUNC_LOG; + RPointerArray attachments; + aMsg.AttachmentListL( attachments ); + TBool found = EFalse; + for ( TInt i=0; iGetDate(); + TLocale currentLocaleSettings; + eventTimeInHomeTime = eventTimeInHomeTime + + (currentLocaleSettings.UniversalTimeOffset()); + eventTimeInHomeTime += currentLocaleSettings.QueryHomeHasDaylightSavingOn() + ? TTimeIntervalHours(1) : TTimeIntervalHours(0); + TDateFormat dateFormat = currentLocaleSettings.DateFormat(); + TChar secondDateSeparator = currentLocaleSettings.DateSeparator( 1 ); + TChar thirdDateSeparator = currentLocaleSettings.DateSeparator( 2 ); + + if ( aAddYearNumer ) + { + switch ( dateFormat ) + { + case EDateAmerican: // US format (mm/dd/yyyy) + { + ret->Des().Format(_L("%02d%c%02d%c%4d"), + eventTimeInHomeTime.DateTime().Month()+1, + (TUint)secondDateSeparator, + eventTimeInHomeTime.DateTime().Day()+1, + (TUint)thirdDateSeparator, + eventTimeInHomeTime.DateTime().Year()); + } + break; + case EDateJapanese: // Japanese format (yyyy/mm/dd) + { + ret->Des().Format( _L("%4d%c%02d%c%02d"), + eventTimeInHomeTime.DateTime().Year(), + (TUint)secondDateSeparator, + eventTimeInHomeTime.DateTime().Month()+1, + (TUint)thirdDateSeparator, + eventTimeInHomeTime.DateTime().Day()+1 ); + } + break; + case EDateEuropean: // European format (dd/mm/yyyy) + default: + { + ret->Des().Format(_L("%02d%c%02d%c%4d"), + eventTimeInHomeTime.DateTime().Day()+1, + (TUint)secondDateSeparator, + eventTimeInHomeTime.DateTime().Month()+1, + (TUint)thirdDateSeparator, + eventTimeInHomeTime.DateTime().Year()); + } + break; + } + } + else + { + switch ( dateFormat ) + { + case EDateAmerican: // US format (mm/dd/yyyy) + { + ret->Des().Format(_L("%02d%c%02d"), + eventTimeInHomeTime.DateTime().Month()+1, + (TUint)secondDateSeparator, + eventTimeInHomeTime.DateTime().Day()+1 ); + } + break; + case EDateJapanese: // Japanese format (yyyy/mm/dd) + { + ret->Des().Format( _L("%02d%c%02d"), + eventTimeInHomeTime.DateTime().Month()+1, + (TUint)thirdDateSeparator, + eventTimeInHomeTime.DateTime().Day()+1 ); + } + break; + case EDateEuropean: // European format (dd/mm/yyyy) + default: + { + ret->Des().Format(_L("%02d%c%02d"), + eventTimeInHomeTime.DateTime().Day()+1, + (TUint)secondDateSeparator, + eventTimeInHomeTime.DateTime().Month()+1 ); + } + break; + } + } + TPtr dataPtr( ret->Des() ); + AknTextUtils::LanguageSpecificNumberConversion( dataPtr ); + return ret; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::TimeTextFromMsgLC +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::TimeTextFromMsgLC( const CFSMailMessage* aMessage ) + { + FUNC_LOG; + TBuf<20> timeStr; + TBuf<20> timeStrFormat; + TTime eventTimeInHomeTime = aMessage->GetDate(); + TLocale currentLocaleSettings; + eventTimeInHomeTime = eventTimeInHomeTime + + (currentLocaleSettings.UniversalTimeOffset()); + eventTimeInHomeTime += currentLocaleSettings.QueryHomeHasDaylightSavingOn() + ? TTimeIntervalHours(1) : TTimeIntervalHours(0); + if( currentLocaleSettings.AmPmSymbolPosition() == ELocaleBefore ) + { + timeStrFormat.Append( KTimeFormatBefore ); + timeStrFormat.Append( KTimeFormatSpace ); + timeStrFormat.Append( KTimeFormatHour ); + timeStrFormat.Append( currentLocaleSettings.TimeSeparator( KSecondSeparator ) ); + timeStrFormat.Append( KTimeFormatMinutes ); + eventTimeInHomeTime.FormatL( timeStr, timeStrFormat ); + } + else + { + timeStrFormat.Append( KTimeFormatHour ); + timeStrFormat.Append( currentLocaleSettings.TimeSeparator( KSecondSeparator ) ); + timeStrFormat.Append( KTimeFormatMinutes ); + timeStrFormat.Append( KTimeFormatSpace ); + timeStrFormat.Append( KTimeFormatAfter ); + eventTimeInHomeTime.FormatL( timeStr, timeStrFormat ); + } + HBufC* dataStr = HBufC::NewL( 1 + timeStr.Length() ); + TPtr dataPtr( dataStr->Des() ); + dataPtr.Append( timeStr ); + CleanupStack::PushL( dataStr ); + AknTextUtils::LanguageSpecificNumberConversion( dataPtr ); + return dataStr; + } + + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ListMsgTimeTextFromMsgLC +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::ListMsgTimeTextFromMsgLC( const CFSMailMessage* aMessage, TBool aDividersInUse ) + { + FUNC_LOG; + // If dividers are in use, returjn normal time text + if ( aDividersInUse ) + { + return TimeTextFromMsgLC( aMessage ); + } + + // If dividers are not in use, today's emails need to use time, others need to use date. + TTime eventTimeInHomeTime = aMessage->GetDate(); + TTime currentTime; + currentTime.HomeTime(); + TLocale currentLocaleSettings; + eventTimeInHomeTime = eventTimeInHomeTime + + (currentLocaleSettings.UniversalTimeOffset()); + eventTimeInHomeTime += currentLocaleSettings.QueryHomeHasDaylightSavingOn() + ? TTimeIntervalHours(1) : TTimeIntervalHours(0); + if ( currentTime.DayNoInYear() == eventTimeInHomeTime.DayNoInYear() && + currentTime.DateTime().Year() == eventTimeInHomeTime.DateTime().Year() ) + { + // Event is today, use time text from msg + return TimeTextFromMsgLC( aMessage ); + } + else + { + // Event is not from today, use date text without year number + return DateTextFromMsgLC( aMessage, EFalse ); + } + } + + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::WeekDayTextFromMsgLC +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::WeekDayTextFromMsgLC( const CFSMailMessage* aMessage, + TBool aUseToday, + TBool aUseYesterday, + TBool& aWasToday, + TBool& aWasYesterday ) + { + FUNC_LOG; + HBufC* ret(0); + TTime eventTimeInHomeTime = aMessage->GetDate(); + TTime currentTime; + currentTime.HomeTime(); + TLocale currentLocaleSettings; + + // Correct current time and event time UTC offset and daylight saving time + eventTimeInHomeTime = eventTimeInHomeTime + + (currentLocaleSettings.UniversalTimeOffset()); + eventTimeInHomeTime += currentLocaleSettings.QueryHomeHasDaylightSavingOn() + ? TTimeIntervalHours(1) : TTimeIntervalHours(0); + + TBool eventTimeIsToday(EFalse); + TBool eventTimeIsYesterday(EFalse); + // Check if year and day number in year are the same, e.g. today + if ( currentTime.DayNoInYear() == eventTimeInHomeTime.DayNoInYear() && + currentTime.DateTime().Year() == eventTimeInHomeTime.DateTime().Year() ) + { + eventTimeIsToday = ETrue; + } + // Check if year and current day number minus one in year are the same, e.g. yesterday + else if ( currentTime.DayNoInYear()-1 == eventTimeInHomeTime.DayNoInYear() && + currentTime.DateTime().Year() == eventTimeInHomeTime.DateTime().Year() ) + { + eventTimeIsYesterday = ETrue; + } + if ( aUseToday && eventTimeIsToday ) + { + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_TODAY ); + aWasToday = ETrue; + } + else if ( aUseYesterday && eventTimeIsYesterday ) + { + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_YESTERDAY ); + aWasYesterday = ETrue; + } + else + { + switch ( eventTimeInHomeTime.DayNoInWeek() ) + { + case EMonday: + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_MONDAY ); + break; + case ETuesday: + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_TUESDAY ); + break; + case EWednesday: + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_WEDNESDAY ); + break; + case EThursday: + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_THURSDAY ); + break; + case EFriday: + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_FRIDAY ); + break; + case ESaturday: + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_SATURDAY ); + break; + case ESunday: + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_WEEEKDAY_SUNDAY ); + break; + } + } + return ret; + } + + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CreateSizeDescLC +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::CreateSizeDescLC( TInt aSizeInBytes, + TBool aShowSizeInBytes ) + { + FUNC_LOG; + HBufC* sizeDesc = NULL; + + if ( aSizeInBytes >= KMega ) // Show in MB with one decimal + { + // The largest possible file size in 32bit architecture is 2^32 bytes = 4096 MB. + // Thus, we need to reserve 4 characters for the megabyte part, one for decimal + // separator, and one for decimal part. + HBufC* numberBuf = HBufC::NewLC(4+1+1); + TPtr numberDes = numberBuf->Des(); + + TInt megaBytePart = aSizeInBytes / KMega; + TInt remainder = aSizeInBytes % KMega; + TInt decimalPart = (remainder*10 + KMega/2) / KMega; // The +KMega/2 is used to get normal rounding rules + // if decimal part gets rounded up to 10, we need to increment the megabyte part + if ( decimalPart == 10 ) + { + megaBytePart++; + decimalPart = 0; + } + + TLocale locale; + TChar decimalSeparator = locale.DecimalSeparator(); + + numberDes.Num( megaBytePart ); + numberDes.Append( decimalSeparator ); + numberDes.AppendNum( decimalPart ); + + if( aShowSizeInBytes ) + { + sizeDesc = StringLoader::LoadL( R_FREESTYLE_EMAIL_UI_SIZE_IN_MB_WITH_BYTES, + *numberBuf, aSizeInBytes ); + } + else + { + sizeDesc = StringLoader::LoadL( R_FREESTYLE_EMAIL_UI_SIZE_IN_MB, *numberBuf ); + } + CleanupStack::PopAndDestroy( numberBuf ); + CleanupStack::PushL( sizeDesc ); + } + else if ( aSizeInBytes >= KKilo || aSizeInBytes == 0 ) // Show in kB without decimals + { + TInt sizeInKB = (aSizeInBytes + KKilo/2) / KKilo; // The +KKilo/2 is used to get normal rounding rules + if( aShowSizeInBytes ) + { + HBufC* numberBuf = HBufC::NewLC(8); + TPtr numberDes = numberBuf->Des(); + numberDes.Num( sizeInKB ); + + sizeDesc = StringLoader::LoadL( R_FREESTYLE_EMAIL_UI_SIZE_IN_KB_WITH_BYTES, + *numberBuf, aSizeInBytes ); + CleanupStack::PopAndDestroy( numberBuf ); + CleanupStack::PushL( sizeDesc ); + } + else + { + sizeDesc = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_SIZE_IN_KB, sizeInKB ); + } + } + else if ( aSizeInBytes > 0 ) // show "less than kilobyte" + { + if( aShowSizeInBytes ) + { + sizeDesc = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_SIZE_LESS_THAN_KB_WITH_BYTES, + aSizeInBytes ); + } + else + { + sizeDesc = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_SIZE_LESS_THAN_KB ); + } + } + else // negative numbers are not supported + { + __ASSERT_DEBUG( EFalse, Panic(EFSEmailUiUnexpectedValue) ); + sizeDesc = KNullDesC().AllocLC(); + } + + // Do number conversion to Arabic/Eastern Arabic/Indic digits when necessary + TPtr des = sizeDesc->Des(); + AknTextUtils::LanguageSpecificNumberConversion( des ); + + return sizeDesc; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CompareMailSubjectsL +// ----------------------------------------------------------------------------- +TInt TFsEmailUiUtility::CompareMailSubjectsL( const CFSMailMessage* aMessage1, + const CFSMailMessage* aMessage2 ) + { + FUNC_LOG; + TInt result( 0 ); + + if ( aMessage1 && aMessage2 ) + { + HBufC* compareSubject1 = CreateSubjectWithoutLocalisedPrefixLC( aMessage1, ETrue ); + compareSubject1->Des().LowerCase(); + HBufC* compareSubject2 = CreateSubjectWithoutLocalisedPrefixLC( aMessage2, ETrue ); + compareSubject2->Des().LowerCase(); + + result = compareSubject1->CompareC( *compareSubject2 ); + + CleanupStack::PopAndDestroy( compareSubject2 ); + CleanupStack::PopAndDestroy( compareSubject1 ); + } + // Check if one subject pointer is valid instead of other -> result is non-zero. + else if ( aMessage1 && !aMessage2 ) + { + result = 1; + } + else if ( !aMessage1 && aMessage2 ) + { + result = -1; + } + return result; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CreateSubjectWithoutLocalisedPrefixLC +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::CreateSubjectWithoutLocalisedPrefixLC( + const CFSMailMessage* aMessage, + TBool aSuppressNotAvailableText /*= EFalse*/ ) + { + FUNC_LOG; + TDesC* subject = &aMessage->GetSubject(); + TPtrC croppedSubject; + if ( subject ) + { + croppedSubject.Set( *subject ); + } + + TBool prefixFound = EFalse; + + do + { + prefixFound = EFalse; + + // Remove leading white space before trying to find the prefix + while( croppedSubject.Length() && + TChar(croppedSubject[0]).IsSpace() ) + { + croppedSubject.Set( croppedSubject.Mid(1) ); + } + + // try to find ":" at the beginning + // Locate : character on location 1,2 and 3 + static const TInt KPrefixMinLength = 1; + static const TInt KPrefixMaxLength = 3; + static const TText KPrefixSeparator = ':'; + TInt separatorPosition = croppedSubject.Locate( KPrefixSeparator ); + if ( separatorPosition >= KPrefixMinLength && + separatorPosition <= KPrefixMaxLength ) + { + TPtrC prefixCandidate = croppedSubject.Left( separatorPosition ); + // Only fully alphabetic prefixes are cropped + TBool isAlpha = ETrue; + for ( TInt i = 0 ; i < prefixCandidate.Length() ; ++i ) + { + if ( !TChar( prefixCandidate[i] ).IsAlpha() ) + { + isAlpha = EFalse; + } + } + if ( isAlpha ) + { + croppedSubject.Set( croppedSubject.Mid( separatorPosition+1 ) ); + prefixFound = ETrue; + } + } + } + while ( prefixFound ); + + HBufC* ret = croppedSubject.AllocLC(); + + // Filter out undesirable characters and remove extra white space + TPtr retPtr = ret->Des(); + FilterListItemTextL( retPtr ); + + // Use "(no subject available)" text if subject is emtpy and this is not forbidden by caller + if ( !ret->Length() && !aSuppressNotAvailableText ) + { + CleanupStack::PopAndDestroy( ret ); + ret = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_NO_SUBJECT ); + } + + return ret; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CreateSubjectTextLC +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::CreateSubjectTextLC( const CFSMailMessage* aMessage ) + { + FUNC_LOG; + HBufC* subjectText = NULL; + + if ( aMessage ) + { + const TDesC* subject = &aMessage->GetSubject(); + if ( subject ) + { + subjectText = subject->AllocLC(); + TPtr ptr( subjectText->Des() ); + FilterListItemTextL( ptr ); + // discard the subject text if it's empty after the filtering + if ( !subjectText->Length() ) + { + CleanupStack::PopAndDestroy( subjectText ); + subjectText = NULL; + } + } + } + + // Use "(no subject available)" text if no other visible subject got + if ( !subjectText ) + { + subjectText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_NO_SUBJECT ); + } + + return subjectText; + } + + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CreateBodyTextLC +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::CreateBodyTextLC( const CFSMailMessage* aMessage ) + { + FUNC_LOG; + HBufC* bodyText = NULL; + + if ( aMessage ) + { + CFSMailMessage* msg = const_cast (aMessage); + CFSMailMessagePart* bodyPart = msg->PlainTextBodyPartL(); + if ( bodyPart ) + { + CleanupStack::PushL( bodyPart ); + bodyText = HBufC::NewLC(bodyPart->ContentSize()); + TPtr ptr = bodyText->Des(); + bodyPart->GetContentToBufferL(ptr, 0); + + FilterListItemTextL( ptr ); + // discard the subject text if it's empty after the filtering + if ( !bodyText->Length() ) + { + CleanupStack::PopAndDestroy( bodyText ); + bodyText = NULL; + } + CleanupStack::PopAndDestroy( bodyPart ); + } + } + + // Use "(no subject available)" text if no other visible subject got + if ( !bodyText ) + { + bodyText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_VIEWER_NO_SUBJECT ); + } + + return bodyText; + } + + + +// --------------------------------------------------------------------------- +// TFsEmailUiUtility::FilterPreviewPaneTextL +// This function crops out tabulator and line feed characters from the given data. +// After that, it will makes sure that there are no consecutive space characters for +// preview pane text +// --------------------------------------------------------------------------- +// +void TFsEmailUiUtility::FilterListItemTextL( TDes& aText ) + { + FUNC_LOG; + _LIT( KCharsToReplace, "\r\n\t\x2028\x2029" ); + + AknTextUtils::ReplaceCharacters( aText, KCharsToReplace, ' ' ); + aText.TrimAll(); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::MessageSizeClass +// ----------------------------------------------------------------------------- +TMessageSizeClass TFsEmailUiUtility::MessageSizeClass( const CFSMailMessage& aMessage ) + { + FUNC_LOG; + TUint msgSize = aMessage.ContentSize(); + TMessageSizeClass sizeClass; + + if ( msgSize < ETiny ) + { + sizeClass = ETiny; + } + else if ( msgSize < ESmall ) + { + sizeClass = ESmall; + } + else if ( msgSize < EMedium ) + { + sizeClass = EMedium; + } + else if ( msgSize < ELarge ) + { + sizeClass = ELarge; + } + else if ( msgSize < EVeryLarge ) + { + sizeClass = EVeryLarge; + } + else if ( msgSize < EHuge ) + { + sizeClass = EHuge; + } + else + { + sizeClass = EColossal; + } + + return sizeClass; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ConvertHtmlToTxtL +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::ConvertHtmlToTxtL( const TDesC& aHtml ) + { + FUNC_LOG; + enum TPrevious + { + ENone, // Nothing special in previous character + EHeadTag, // We are in head tag + ETagEnd, // Previous character contained tag ending + ESpace // Previous character contained space + }; + + _LIT( KTagStart, "<" ); + _LIT( KTagEnd, ">" ); + _LIT( KHeadStart, "head" ); + _LIT( KHeadEnd, "/head>" ); + + TInt tagCount = 0; // Amount of nested tags + TInt sizeToParse = aHtml.Length(); // How much we have to parse + TPrevious previous = ENone; // Previous characters type. + HBufC* txtBuffer = HBufC::NewLC( sizeToParse ); + + // HTML parsing. + TInt lineFeedCount = 0; + TInt index = 0; // Parsing index + for ( index = 0; index < sizeToParse; index++ ) + { + // Get the next character + TPtrC ptr = aHtml.Mid( index, 1 ); + + // Are we in header + if ( previous == EHeadTag ) + { + // Is this a start of end tag + if ( ptr.Compare( KTagStart ) == 0 && + index + KHeadEnd().Length() < sizeToParse ) + { + ptr.Set( aHtml.Mid( index + 1, KHeadEnd().Length() ) ); + if ( ptr.Compare( KHeadEnd ) == 0 ) + { + previous = ETagEnd; + index += KHeadEnd().Length(); + } + } + + } + // Is this a start of the tag + else if ( ptr.Compare( KTagStart ) == 0 ) + { + lineFeedCount = 0; + + if ( index + KHeadStart().Length() < sizeToParse ) + { + ptr.Set( aHtml.Mid( index + 1, KHeadStart().Length() ) ); + if ( ptr.Compare( KHeadStart ) == 0 ) + { + previous = EHeadTag; + index += KHeadStart().Length(); + } + } + + if ( previous != EHeadTag ) + { + // Increase the number of nested tags + tagCount++; + previous = ENone; + } + } + // Are we inside of the tag + else if ( tagCount > 0 ) + { + // Is this the end of the tag + if ( ptr.Compare( KTagEnd ) == 0 ) + { + tagCount--; + if ( tagCount < 0 ) + { + // To avoid unnecessary errors convert negative + // values to zero. + tagCount = 0; + } + if ( tagCount == 0 ) + { + previous = ETagEnd; + } + } + } + // We are not inside of the tag + else + { + if ( previous == ETagEnd ) + { + // Skip multiple line feed and carriage return characters + if ( ptr.Compare( KCarriageReturn ) != 0 && + ptr.Compare( KLineFeed ) != 0 ) + { + if ( lineFeedCount > 0 ) + { + txtBuffer->Des().Append( KLineFeed ); + lineFeedCount = 0; + } + txtBuffer->Des().Append( ptr ); + previous = ENone; + } + else if ( ptr.Compare( KLineFeed ) == 0 ) + { + lineFeedCount++; + } + } + else + { + if ( previous == ESpace ) + { + // Skip consecutive spaces + // if ( ptr.Compare( KSpace ) != 0 ) + // { + txtBuffer->Des().Append( ptr ); + // } + } + else + { + txtBuffer->Des().Append( ptr ); + } + if ( ptr.Compare( KSpace ) == 0 ) + { + previous = ESpace; + } + else + { + previous = ENone; + } + } + } + } + + CleanupStack::Pop( txtBuffer ); + + return txtBuffer; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CompareMailAddressesL +// ----------------------------------------------------------------------------- +TInt TFsEmailUiUtility::CompareMailAddressesL( CFSMailAddress* aAddr1, + CFSMailAddress* aAddr2 ) + { + FUNC_LOG; + TInt result( 0 ); + if ( aAddr1 && aAddr2 ) + { + HBufC* compareName1 = CreateCompareNameForAddressLC( *aAddr1 ); + HBufC* compareName2 = CreateCompareNameForAddressLC( *aAddr2 ); + + result = compareName1->CompareC( *compareName2 ); + + CleanupStack::PopAndDestroy( compareName2 ); + CleanupStack::PopAndDestroy( compareName1 ); + } + // Check if one address pointer is valid instead of other -> result is non-zero. + else if ( ( aAddr1 && !aAddr2 ) ) + { + result = 1; + } + else if ( !aAddr1 && aAddr2 ) + { + result = -1; + } + return result; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CreateCompareNameForAddressLC +// ----------------------------------------------------------------------------- +HBufC* TFsEmailUiUtility::CreateCompareNameForAddressLC( const CFSMailAddress& aAddress ) + { + FUNC_LOG; + HBufC* result = NULL; + + TDesC* displayName = &aAddress.GetDisplayName(); + TDesC* emailAddress = &aAddress.GetEmailAddress(); + + if ( displayName && displayName->Length() ) + { + result = displayName->AllocLC(); + } + else if ( emailAddress && emailAddress->Length() ) + { + result = emailAddress->AllocLC(); + } + else + { + result = KNullDesC().AllocLC(); + } + + result->Des().LowerCase(); + return result; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CountRecepients +// ----------------------------------------------------------------------------- +TInt TFsEmailUiUtility::CountRecepients( CFSMailMessage* aMsgPtr ) + { + FUNC_LOG; + return aMsgPtr->GetToRecipients().Count() + aMsgPtr->GetCCRecipients().Count(); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CountRecipientsSmart +// Calculates recipient count from To and Cc recipient as well as tries to +// see if the message is sent via message list. +// ----------------------------------------------------------------------------- +TInt TFsEmailUiUtility::CountRecipientsSmart( CFreestyleEmailUiAppUi& aAppUi, CFSMailMessage* aMsgPtr ) + { + FUNC_LOG; + TInt numRecipients( CountRecepients( aMsgPtr ) ); + if ( numRecipients == 1 ) + { + CFSMailBox* mailBox = NULL; + + TRAPD( error, mailBox = aAppUi.GetMailClient()->GetMailBoxByUidL( aMsgPtr->GetMailBoxId() ) ); + + if (mailBox && !error) + { + //check if the malbox ownmailaddress is same as the recipients email address. If not, then assume that the + //email is a distribution list and we need to inc num of Recipients so that "Reply ALL" option appears in UI. + if ( aMsgPtr->GetToRecipients().Count() ) + { + if ( mailBox->OwnMailAddress().GetEmailAddress().CompareF(aMsgPtr->GetToRecipients()[0]->GetEmailAddress()) ) + { + numRecipients++; + } + } + if ( aMsgPtr->GetCCRecipients().Count() ) + { + if ( mailBox->OwnMailAddress().GetEmailAddress().CompareF(aMsgPtr->GetCCRecipients()[0]->GetEmailAddress()) ) + { + numRecipients++; + } + } + if ( aMsgPtr->GetBCCRecipients().Count() ) + { + if ( mailBox->OwnMailAddress().GetEmailAddress().CompareF(aMsgPtr->GetBCCRecipients()[0]->GetEmailAddress()) ) + { + numRecipients++; + } + } + } + + delete mailBox; + } + + return numRecipients; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::IsMessageBodyLargeL +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::IsMessageBodyLargeL( CFSMailMessage* aMessage ) + { + FUNC_LOG; + TBool ret = EFalse; + if ( aMessage ) + { + CFSMailMessagePart* plainTextBodyPart = aMessage->PlainTextBodyPartL(); + CleanupStack::PushL( plainTextBodyPart ); + CFSMailMessagePart* htmlBodyPart = aMessage->HtmlBodyPartL(); + CleanupStack::PushL( htmlBodyPart ); + + if ( (plainTextBodyPart && plainTextBodyPart->FetchedContentSize() > KLargePlainTextSizeLimit) || + (htmlBodyPart && htmlBodyPart->FetchedContentSize() > KLargeHtmlTextSizeLimit) ) + { + ret = ETrue; + } + + CleanupStack::PopAndDestroy( htmlBodyPart ); + CleanupStack::PopAndDestroy( plainTextBodyPart ); + } + return ret; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::GetUnreadMsgIconL +// ----------------------------------------------------------------------------- +TFSEmailUiTextures TFsEmailUiUtility::GetUnreadMsgIcon( CFSMailMessage* aMsgPtr ) + { + FUNC_LOG; + TFSEmailUiTextures textureId; + // Unread calendar invitation + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_CalendarMsg )) + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Important ) ) + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Attachments ) ) + { + textureId = EMessageCalInvitationAttachmentsHighPrio ; + } + else + { + textureId = EMessageCalInvitationHighPrio; + } + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Low ) ) + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Attachments ) ) + { + textureId = EMessageCalInvitationAttachmentsLowPrio; + } + else + { + textureId = EMessageCalInvitationLowPrio; + } + } + else + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Attachments ) ) + { + textureId = EMessageCalInvitationAttachments; + } + else + { + textureId = EMessageCalInvitation; + } + } + // + TBool cancellationMsg = EFalse; + TRAP_IGNORE( cancellationMsg = IsMrCancellationMsgL( aMsgPtr ) ); + if ( cancellationMsg ) + { + textureId = EMessageCalInvitationCancelled; + } + // + } + else // Normal message icons + { + // Check whether msg has attachment or not + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Attachments )) // Has attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Important )) // High priority, has attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageUnreadRepliedHighPrioIconAttachment; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageUnreadForwardedHighPrioIconAttachment; + } + else + { + textureId = EMessageHighPrioUnreadIconAttachment; + } + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Low ) ) // Low priority, has attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageUnreadRepliedLowPrioIconAttachment; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageUnreadForwardedLowPrioIconAttachment; + } + else + { + textureId = EMessageLowPrioUnreadIconAttachment; + } + } + else // Normal priority, has attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageUnreadRepliedIconAttachment; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageUnreadForwardedIconAttachment; + } + else + { + textureId = EMessageUnreadIconAttachment; + } + } + } + + else // No attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Important )) // High priority, no attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageUnreadRepliedHighPrioIcon; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageUnreadForwardedHighPrioIcon; + } + else + { + textureId = EMessageHighPrioUnreadIcon; + } + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Low ) ) // Low priority, no attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageUnreadRepliedLowPrioIcon; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageUnreadForwardedLowPrioIcon; + } + else + { + textureId = EMessageLowPrioUnreadIcon; + } + } + else // Normal priority, no attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageUnreadRepliedIcon; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageUnreadForwardedIcon; + } + else + { + textureId = EMessageUnreadIcon; + } + } + } + } + return textureId; + } + + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::GetReadMsgIconL +// ----------------------------------------------------------------------------- +TFSEmailUiTextures TFsEmailUiUtility::GetReadMsgIcon( CFSMailMessage* aMsgPtr ) + { + FUNC_LOG; + TFSEmailUiTextures textureId; + // Check for calendar invitation first + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_CalendarMsg )) + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Important ) ) + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Attachments ) ) + { + textureId = EMessageCalInvitationReadAttachmentsHighPrio ; + } + else + { + textureId = EMessageCalInvitationReadHighPrio; + } + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Low ) ) + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Attachments ) ) + { + textureId = EMessageCalInvitationReadAttachmentsLowPrio; + } + else + { + textureId = EMessageCalInvitationReadLowPrio; + } + } + else + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Attachments ) ) + { + textureId = EMessageCalInvitationReadAttachments; + } + else + { + textureId = EMessageCalInvitationRead; + } + } + // + TBool cancellationMsg = EFalse; + TRAP_IGNORE( cancellationMsg = IsMrCancellationMsgL( aMsgPtr ) ); + if ( cancellationMsg ) + { + textureId = EMessageCalInvitationCancelled; + } + // + } + else // Normal message icons + { + // Check whether msg has attachment or not + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Attachments )) // Has attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Important )) // High priority, has attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageReadRepliedHighPrioIconAttachment; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageReadForwardedHighPrioIconAttachment; + } + else + { + textureId = EMessageHighPrioReadIconAttachment; + } + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Low ) ) // Low priority, has attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageReadRepliedLowPrioIconAttachment; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageReadForwardedLowPrioIconAttachment; + } + else + { + textureId = EMessageLowPrioReadIconAttachment; + } + } + else // Normal priority, has attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageReadRepliedIconAttachment; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageReadForwardedIconAttachment; + } + else + { + textureId = EMessageReadIconAttachment; + } + } + } + else // No attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Important )) // High priority, no attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageReadRepliedHighPrioIcon; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageReadForwardedHighPrioIcon; + } + else + { + textureId = EMessageHighPrioReadIcon; + } + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Low ) ) // Low priority, no attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageReadRepliedLowPrioIcon; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageReadForwardedLowPrioIcon; + } + else + { + textureId = EMessageLowPrioReadIcon; + } + } + else // Normal priority, no attachments + { + if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Answered ) ) + { + textureId = EMessageReadRepliedIcon; + } + else if ( aMsgPtr->IsFlagSet( EFSMsgFlag_Forwarded ) ) + { + textureId = EMessageReadForwardedIcon; + } + else + { + textureId = EMessageReadIcon; + } + } + } + } + return textureId; + } + +// +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::IsMrCancellationMsgL +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::IsMrCancellationMsgL( CFSMailMessage* aMsgPtr ) + { + FUNC_LOG; + TBool isCancel = EFalse; + + if ( !iMrViewer ) + { + if ( !iMrViewerCallback ) + { + iMrViewerCallback = new (ELeave) CMrViewerEmptyCallback; + } + iMrViewer = CESMRIcalViewer::NewL( *iMrViewerCallback ); + } + + TESMRMeetingRequestMethod method = iMrViewer->ResolveMeetingRequestMethodL(*aMsgPtr); + if ( method == EESMRMeetingRequestMethodCancellation ) + { + isCancel = ETrue; + } + + return isCancel; + } +// + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CopyToClipboardL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::CopyToClipboardL( const TDesC &aBuf ) + { + FUNC_LOG; + CClipboard* cb = CClipboard::NewForWritingLC( CCoeEnv::Static()->FsSession() ); + + cb->StreamDictionary().At( KClipboardUidTypePlainText ); + + CPlainText* plainText = CPlainText::NewL(); + CleanupStack::PushL( plainText ); + + plainText->InsertL( 0 , aBuf ); + + plainText->CopyToStoreL( cb->Store(), cb->StreamDictionary(), 0, plainText->DocumentLength() ); + + CleanupStack::PopAndDestroy( plainText ); + cb->CommitL(); + CleanupStack::PopAndDestroy( cb ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::ToggleEmailIconL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::ToggleEmailIconL(TBool aIconOn ) + { + FUNC_LOG; + if(aIconOn) + { + RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsNewEmailStatus, ECoreAppUIsNewEmail ); + } + else + { + RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsNewEmailStatus, ECoreAppUIsNoNewEmail ); + } + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::DisplayMsgsMovedNoteL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::DisplayMsgsMovedNoteL( TInt aMsgCount, const TFSMailMsgId aDestinationFolderId, + TBool /*aIsWaitingNote*/ ) + { + FUNC_LOG; + if ( aDestinationFolderId.Id() != 0 ) + { + CFreestyleEmailUiAppUi* appUi = (CFreestyleEmailUiAppUi*)CCoeEnv::Static()->AppUi(); + CFSMailFolder* folder = appUi->GetMailClient()->GetFolderByUidL( appUi->GetActiveMailboxId(), aDestinationFolderId ); + if ( folder ) + { + CleanupStack::PushL( folder ); + HBufC* folderName(0); + TInt folderType = folder->GetFolderType(); + switch ( folderType ) + { + case EFSInbox: + { + folderName = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_FOLDER_LIST_INBOX ); + } + break; + case EFSOutbox: + { + folderName = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_FOLDER_LIST_OUTBOX ); + } + break; + case EFSDraftsFolder: + { + folderName = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_FOLDER_LIST_DRAFTS ); + } + break; + case EFSSentFolder: + { + folderName = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_FOLDER_LIST_SENT ); + } + break; + case EFSDeleted: + { + folderName = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_FOLDER_LIST_DELETED ); + } + break; + default: + { + folderName = HBufC::NewLC( folder->GetFolderName().Length() ); + folderName->Des().Append( folder->GetFolderName() ); + } + break; + } + if ( aMsgCount == 1) + { + HBufC* noteText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_MESSAGE_TO_FOLDER, *folderName ); + // replace global note with aknnote to allow exiting with red key + //CAknGlobalNote* globalNote = CAknGlobalNote::NewLC(); + //globalNote->ShowNoteL( EAknGlobalInformationNote, *noteText ); + CAknInformationNote* note = new (ELeave) CAknInformationNote( ETrue ); + note->ExecuteLD( *noteText ); + CleanupStack::PopAndDestroy( noteText ); + //CleanupStack::PopAndDestroy( 2 ); + // + } + else if ( aMsgCount > 1 ) + { + HBufC* noteText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_MESSAGES_TO_FOLDER, *folderName, aMsgCount ); + // replace global note with aknnote to allow exiting with red key + //CAknGlobalNote* globalNote = CAknGlobalNote::NewLC(); + //globalNote->ShowNoteL( EAknGlobalInformationNote, *noteText ); + CAknInformationNote* note = new (ELeave) CAknInformationNote( ETrue ); + note->ExecuteLD( *noteText ); + CleanupStack::PopAndDestroy( noteText ); + // CleanupStack::PopAndDestroy( 2 ); + // + } + CleanupStack::PopAndDestroy( folderName ); + CleanupStack::PopAndDestroy( folder ); + } + } + } + +// --------------------------------------------------------------------------- +// TFsEmailUiUtility::IsOfflineModeL +// --------------------------------------------------------------------------- +// +TBool TFsEmailUiUtility::IsOfflineModeL() + { + FUNC_LOG; + TBool isOffline( EFalse ); + TInt status( ECoreAppUIsNetworkConnectionAllowed ); + + CRepository* cenRep = CRepository::NewL( KCRUidCoreApplicationUIs ); + if ( cenRep ) + { + cenRep->Get( KCoreAppUIsNetworkConnectionAllowed, status ); + } + delete cenRep; + + if ( status == ECoreAppUIsNetworkConnectionNotAllowed ) + { + isOffline = ETrue; + } + + return isOffline; + } + +// --------------------------------------------------------------------------- +// TFsEmailUiUtility::StripDisplayName +// Drop out unwanted characters from display name such as <> and "" +// --------------------------------------------------------------------------- +void TFsEmailUiUtility::StripDisplayName( HBufC& aDisplayName ) + { + FUNC_LOG; + // Drop out unwanted chars from display name + if ( aDisplayName.Length() > 2) + { + // Drop out <> and "" characters. + if ( aDisplayName.Locate('"') == 0 ) // check if first char is quation mark + { + if ( aDisplayName.LocateReverse('"') == aDisplayName.Length()-1 ) // last char + { + // Remove first and last + aDisplayName.Des().Delete(0,1); + aDisplayName.Des().Delete(aDisplayName.Length()-1,1); + } + } + else if ( aDisplayName.Locate('<') == 0 ) // Else check if first char is bracket + { + if ( aDisplayName.LocateReverse('>') == aDisplayName.Length()-1 ) // last char bracket + { + // Remove first and last + aDisplayName.Des().Delete(0,1); + aDisplayName.Des().Delete(aDisplayName.Length()-1,1); + } + } + } + } + +// --------------------------------------------------------------------------- +// TFsEmailUiUtility::DisplayCreateMailboxQueryL +// @return ETrue if user answered "Yes", EFalse if user answered "No" +// --------------------------------------------------------------------------- +// +TBool TFsEmailUiUtility::DisplayCreateMailboxQueryL() + { + FUNC_LOG; + // load text from resource + HBufC* question = StringLoader::LoadLC( R_FS_EMAIL_SETTINGS_ADD_MAILBOX_TXT ); + + // show dialog + TRequestStatus status = KRequestPending; + CAknGlobalConfirmationQuery* query = CAknGlobalConfirmationQuery::NewL(); + CleanupStack::PushL( query ); + query->ShowConfirmationQueryL( status, *question, R_AVKON_SOFTKEYS_YES_NO ); + User::WaitForRequest( status ); + + CleanupStack::PopAndDestroy( 2 ); // query question + + return ( status.Int() == EAknSoftkeyYes ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::BringFsEmailToForeground +// ----------------------------------------------------------------------------- +// +void TFsEmailUiUtility::BringFsEmailToForeground() + { + FUNC_LOG; + TApaTaskList taskList( CEikonEnv::Static()->WsSession() ); + TApaTask task = taskList.FindApp( KFSEmailUiUid ); + if ( task.Exists() ) + { + task.BringToForeground(); + } + } + +// ----------------------------------------------------------------------------- +// Creates a displayname of firstname and lastname components +// ----------------------------------------------------------------------------- +// +HBufC* TFsEmailUiUtility::CreateDisplayNameLC( const TDesC& aFirstname, + const TDesC& aLastname ) + { + FUNC_LOG; + return CreateDisplayNameLC( aFirstname, aLastname, KNullDesC ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CreateDisplayNameLC +// ----------------------------------------------------------------------------- +// +HBufC* TFsEmailUiUtility::CreateDisplayNameLC( const TDesC& aFirstname, + const TDesC& aLastname, const TDesC& aEmailField ) + { + FUNC_LOG; + HBufC* displayname = NULL; + + if ( aFirstname.Length() == 0 ) + { + if ( aLastname.Length() == 0 ) + { + //There's just the email address for Displayname + displayname = aEmailField.AllocLC(); + } + else + { + //Lastname = displayname + displayname = aLastname.AllocLC(); + } + } + + else if ( aLastname.Length() == 0 ) + { + //Firstname = displayname + displayname = aFirstname.AllocLC(); + } + + else + { + //Displayname = "firstname lastname" + displayname = HBufC::NewLC( aFirstname.Length() + + KSpace().Length() + + aLastname.Length() ); + displayname->Des().Copy( aFirstname ); + displayname->Des().Append( KSpace ); + displayname->Des().Append( aLastname ); + } + + return displayname; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::GetFullIconFileNameL +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::GetFullIconFileNameL( TDes& aFileName ) + { + FUNC_LOG; + aFileName.Zero(); + aFileName.Copy( KDC_APP_BITMAP_DIR ); + aFileName.Append( KFsEmailIconFileName ); + User::LeaveIfError( CompleteWithAppPath( aFileName ) ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::DoFileExtensionsMatchL +// ----------------------------------------------------------------------------- +TBool TFsEmailUiUtility::DoFileExtensionsMatchL( const TDesC& aFileName1, + const TDesC& aFileName2 ) + { + FUNC_LOG; + TParse parse1; + TParse parse2; + + parse1.Set( aFileName1, NULL, NULL ); + parse2.Set( aFileName2, NULL, NULL ); + + HBufC* ext1 = parse1.Ext().AllocLC(); + HBufC* ext2 = parse2.Ext().AllocLC(); + + ext1->Des().LowerCase(); + ext2->Des().LowerCase(); + + TBool match = (*ext1 == *ext2); + + CleanupStack::PopAndDestroy( ext2 ); + CleanupStack::PopAndDestroy( ext1 ); + + return match; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::CopyFileToTempDirL +// Makes a copy of given file to the temp directory of FsEmailUI. +// Caller is reponsible of closing the returned file handle. +// ----------------------------------------------------------------------------- +RFile TFsEmailUiUtility::CopyFileToTempDirL( const RFile& aSourceFile, + const TDesC& aTargetFileName ) + { + FUNC_LOG; + RFs fs( CEikonEnv::Static()->FsSession() ); + + // Remove any illegal characters from the target file name + TFileName targetFileName = aTargetFileName.Right( KMaxFileName ); // truncate just in case; make sure that any file extension remains + _LIT( KIllegalCharacters, "*?\\<>:\"/|\r\n\t\x2028\x2029" ); + const TText KReplacementChar = '_'; + AknTextUtils::ReplaceCharacters( targetFileName, KIllegalCharacters, KReplacementChar ); + targetFileName.Trim(); + // File name can't begin nor end with dot (.) and cannot be empty + if ( !targetFileName.Length() ) + { + targetFileName.Append( KReplacementChar ); + } + else + { + if ( targetFileName[0] == '.' ) + { + targetFileName[0] = KReplacementChar; + } + if ( targetFileName[ targetFileName.Length()-1 ] == '.' ) + { + targetFileName[ targetFileName.Length()-1 ] = KReplacementChar; + } + } + + // If we still couldn't create a legal name, then use the original name as fallback solution + if ( !fs.IsValidName( targetFileName ) ) + { + aSourceFile.Name( targetFileName ); + } + + // Construct target file full name + TFileName targetFilePath; + GetTempPathL( fs, targetFilePath ); + targetFilePath.Append( targetFileName ); + + CFileMan* fileMan = CFileMan::NewL( fs ); + TInt err = fileMan->Copy( aSourceFile, targetFilePath ); + delete fileMan; + // KErrInUse ignoring check is needed because copying might not succeed + // if file already exists and handle remains open. + if ( err != KErrNone && err != KErrInUse ) + { + User::LeaveIfError( err ); + } + + // Open the copied file + RFile resultFile; + err = resultFile.Open( fs, targetFilePath, EFileRead | EFileShareReadersOnly ); + User::LeaveIfError( err ); + + return resultFile; + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::EraseTempDir +// Deletes all files from our temporary directory +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::EraseTempDir() + { + FUNC_LOG; + RFs fs( CEikonEnv::Static()->FsSession() ); + + TFileName deleteNamePattern; + TRAPD( err, GetTempPathL( fs, deleteNamePattern ) ); + if ( !err ) + { + deleteNamePattern.Append( '*' ); + BaflUtils::DeleteFile( fs, deleteNamePattern ); + } + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::GetTempPathL +// Get EmailUI temp directory path. Creates the directory if it does not exist. +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::GetTempPathL( RFs& aFs, TDes& aPath ) + { + FUNC_LOG; + _LIT( KDriveCPath, "C:" ); + + TInt err = aFs.PrivatePath( aPath ); + User::LeaveIfError( err ); + + aPath.Insert( 0, KDriveCPath ); + aPath.Append( KFsEmailTempDirName ); + BaflUtils::EnsurePathExistsL( aFs, aPath ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::EnsureFsMailServerIsRunning +// Checks if FSMailServer is running. If not, then launches it. +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::EnsureFsMailServerIsRunning( RWsSession& aWsSession ) + { + FUNC_LOG; + TRAP_IGNORE( EnsureFsMailServerIsRunningL( aWsSession ) ); + } + +// ----------------------------------------------------------------------------- +// TFsEmailUiUtility::EnsureFsMailServerIsRunningL +// Checks if FSMailServer is running. If not, then launches it. +// ----------------------------------------------------------------------------- +void TFsEmailUiUtility::EnsureFsMailServerIsRunningL( RWsSession& aWsSession ) + { + FUNC_LOG; + + TApaTaskList taskList( aWsSession ); + TApaTask task = taskList.FindApp( KFSMailServerUid ); + + if ( !task.Exists() ) + { + // FSMailServer is not running, try to launch it + + // Get this process' file name to get the correct drive letter + RProcess process; + TFileName processFileName = process.FileName(); + process.Close(); + + // Parse the full path to FSMailServer exe + TParse parse; + User::LeaveIfError( parse.Set( KFSMailServerExe, &processFileName, NULL) ); + + // Store the full path + processFileName = parse.FullName(); + + CApaCommandLine* cmdLine = CApaCommandLine::NewLC(); + cmdLine->SetExecutableNameL( processFileName ); + // Launch FSMailServer in background so that it doesn't steal + // the focus during it's construction + cmdLine->SetCommandL( EApaCommandBackground ); + + RApaLsSession ls; + User::LeaveIfError( ls.Connect() ); + CleanupClosePushL( ls ); + + TThreadId threadId; + // Is there anything we can do in case of error? + // Try to launch from another drive etc.? + TInt error = ls.StartApp( *cmdLine, threadId ); + + CleanupStack::PopAndDestroy( &ls ); + CleanupStack::PopAndDestroy( cmdLine ); + } + } + + + +///////////////////////////////////////////////////////////////////////////////// +// ACTION MENU HANDLER +// + +//Singleton* Singleton::pinstance = 0; +// Initialize static member variables +CFscContactActionMenu* CFSEmailUiActionMenu::iActionMenu = NULL; +TFileName CFSEmailUiActionMenu::iIconFilePath; +RPointerArray CFSEmailUiActionMenu::iIconArray; + +CFSEmailUiActionMenu* CFSEmailUiActionMenu::NewL( CFreestyleEmailUiAppUi* aAppUi ) + { + FUNC_LOG; + CFSEmailUiActionMenu* self = new (ELeave) CFSEmailUiActionMenu( aAppUi ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +CFSEmailUiActionMenu::CFSEmailUiActionMenu( CFreestyleEmailUiAppUi* aAppUi ) + : iAppUi( aAppUi ) + { + + } + +CFSEmailUiActionMenu::~CFSEmailUiActionMenu() + { + FUNC_LOG; + if( iActionMenu ) + { + delete iActionMenu; + } + if ( iService ) + { + delete iService; + } + iIconArray.ResetAndDestroy(); + } + +void CFSEmailUiActionMenu::ConstructL() + { + FUNC_LOG; + if( !iActionMenu ) + { + iService = CFscContactActionService::NewL( iAppUi->GetVPbkManagerL() ); + iActionMenu = CFscContactActionMenu::NewL( *iService ); + } + TFsEmailUiUtility::GetFullIconFileNameL( iIconFilePath ); + } + +CFscContactActionMenu* CFSEmailUiActionMenu::GetActionMenu() + { + return iActionMenu; + } + +void CFSEmailUiActionMenu::RemoveAllL() + { + FUNC_LOG; + if ( iIconArray.Count() == 0 ) + { + CreateIconsL(); + } + iActionMenu->Model().RemoveAll( ETrue ); + } + +void CFSEmailUiActionMenu::AddCustomItemL( TActionMenuCustomItemId aItemId ) + { + FUNC_LOG; + if ( iIconArray.Count() == 0 ) + { + CreateIconsL(); + } + HBufC* itemText = NULL; + CGulIcon* itemIcon = iIconArray[aItemId-1]; + switch( aItemId ) + { + case FsEActionMenuOpen: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_OPEN ); + } + break; + case FsEActionMenuOpenCalendarEvent: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_OPEN ); + } + break; + case FsEActionMenuReply: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_REPLY ); + } + break; + + case FsEActionMenuReplyAll: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_REPLY_ALL ); + } + break; + + case FsEActionMenuForward: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_FORWARD ); + } + break; + + case FsEActionMenuDelete: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_DELETE ); + } + break; + + case FsEActionMenuAccept: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ACCEPT ); + } + break; + + case FsEActionMenuTentative: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_TENTATIVE ); + } + break; + + case FsEActionMenuDecline: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_DECLINE ); + } + break; + + case FsEActionMenuRemoveFormCal: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_REM_FROM_CAL ); + } + break; + + case FsEActionMenuMarkRead: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_MARK_READ ); + } + break; + + case FsEActionMenuMarkUnread: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_MARK_UNREAD ); + } + break; + + case FsEActionMenuCall: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_CALL ); + } + break; + // video call + case FsEActionMenuCallVideo: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_CALL_VIDEO ); + } + break; + // + case FsEActionMenuCreateMessage: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_CREATE_MESSAGE ); + } + break; + case FsEActionMenuCreateEmail: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_CREATE_EMAIL ); + } + break; + case FsEActionMenuContactDetails: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_CONTACT_DETAILS ); + } + break; + + case FsEActionMenuAddToContacts: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ADD_TO_CONTACTS ); + } + break; + + case FsEActionMenuRemoteLookup: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_REMOTE_LOOKUP ); + } + break; + + case FsEActionMenuMove: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_MOVE ); + } + break; + + case FsEActionMenuMoveToDrafts: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_MOVE_TO_DRAFTS ); + } + break; + case FsEActionMenuOpenInWeb: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_OPEN_IN_WEB ); + } + break; + case FsEActionMenuOpenInIntranet: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_OPEN_IN_INTRA ); + } + break; + case FsEActionMenuBookmark: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_BOOKMARK ); + } + break; + case FsEActionAttachmentOpen: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_OPEN ); + } + break; + case FsEActionAttachmentDownload: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_DOWNLOAD ); + } + break; + case FsEActionAttachmentCancelDownload: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_CANCEL ); + } + break; + case FsEActionAttachmentSave: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_SAVE ); + } + break; + case FsEActionAttachmentAdd: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_ADD ); + } + break; + case FsEActionAttachmentRemove: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_REMOVE ); + } + break; + case FsEActionAttachmentViewAll: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_VIEW_ALL ); + } + break; + case FsEActionAttachmentDownloadAll: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_DOWNLOAD_ALL ); + } + break; + + case FsEActionAttachmentCancelAllDownloads: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_CANCEL_ALL ); + } + break; + case FsEActionAttachmentSaveAll: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_SAVE_ALL ); + } + break; + case FsEActionAttachmentRemoveAll: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_REMOVE_ALL ); + } + break; + case FsEActionAttachmentClearFetchedContent: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_CLEAR_FETCHED ); + } + break; + case FsEActionAttachmentRemoveUnfetchedAttachment: + { + itemText = StringLoader::LoadLC( R_FREESTYLE_EMAIL_UI_AM_ATTACH_REMOVE_UNFETCHED ); + } + break; + default: + { + itemText = KNullDesC().AllocLC(); + } + break; + } + + TUid itemUid; + itemUid.iUid = TInt(aItemId); + + CleanupStack::PushL( itemIcon ); + CFscContactActionMenuItem* menuItem = iActionMenu->Model().NewMenuItemL( *itemText, itemIcon, KActionMenuItemNormalPriority, EFalse, itemUid); + CleanupStack::PushL( menuItem ); + iActionMenu->Model().AddItemL( menuItem ); + CleanupStack::Pop( menuItem ); + CleanupStack::Pop( itemIcon ); + CleanupStack::PopAndDestroy( itemText ); + } + +void CFSEmailUiActionMenu::AddCustomItemsL( RFsEActionMenuIdList aItemList ) + { + FUNC_LOG; + for( TInt i = 0; i < aItemList.Count(); i++ ) + { + AddCustomItemL( aItemList[i] ); + } + } + +// +void CFSEmailUiActionMenu::Dismiss( TBool aSlide ) + { + FUNC_LOG; + if( iActionMenu ) + { + iActionMenu->Dismiss( aSlide ); + } + } +// + +TActionMenuCustomItemId CFSEmailUiActionMenu::ExecuteL( + TFscContactActionMenuPosition aPosition, + TInt aIndex, + MFsActionMenuPositionGiver* aPositionGiver) + { + FUNC_LOG; + if ( iIconArray.Count() == 0 ) + { + CreateIconsL(); + } + TFscActionMenuResult menuResult = iActionMenu->ExecuteL( aPosition, aIndex, aPositionGiver ); + if ( menuResult == EFscCustomItemSelected ) + { + return ResolveSelectedCustomItemIdL(); + } + else if( menuResult == EFscCasItemSelectedAndExecuted ) + { + return FsEActionMenuCasItemSelectedAndExecuted; + } + else + { + return FsEActionMenuDismissed; + } + } + +TActionMenuCustomItemId CFSEmailUiActionMenu::ExecuteL( + RFsEActionMenuIdList aItemList, + TFscContactActionMenuPosition aPosition, + TInt aIndex, + MFsActionMenuPositionGiver* aPositionGiver) + { + FUNC_LOG; + if ( iIconArray.Count() == 0 ) + { + CreateIconsL(); + } + RemoveAllL(); + AddCustomItemsL( aItemList ); + return ExecuteL( aPosition, aIndex, aPositionGiver ); + } +// + + +TActionMenuCustomItemId CFSEmailUiActionMenu::ResolveSelectedCustomItemIdL() + { + FUNC_LOG; + if ( iIconArray.Count() == 0 ) + { + CreateIconsL(); + } + TInt itemIndex = iActionMenu->FocusedItemIndex(); + TUid itemUid = iActionMenu->Model().ItemL( itemIndex ).ImplementationUid(); + + return TActionMenuCustomItemId( itemUid.iUid ); + } + +void CFSEmailUiActionMenu::CreateIconsL() + { + FUNC_LOG; + iIconArray.ResetAndDestroy(); + + // UPDATE ICONS! +// icons changed + // NOTE: Must be appended same order as are in TActionMenuCustomItemIds! + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_indi_cmail_read, EMbmFreestyleemailuiQgn_indi_cmail_read_mask ) ); // FsEActionMenuOpen + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_indi_cmail_calendar_event_read, EMbmFreestyleemailuiQgn_indi_cmail_calendar_event_read_mask ) ); // FsEActionMenuOpen + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_reply, EMbmFreestyleemailuiQgn_prop_cmail_action_reply_mask ) ); // FsEActionMenuReply + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_reply_all, EMbmFreestyleemailuiQgn_prop_cmail_action_reply_all_mask ) ); // FsEActionMenuReplyAll + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_forward, EMbmFreestyleemailuiQgn_prop_cmail_action_forward_mask ) ); // FsEActionMenuForward + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_delete, EMbmFreestyleemailuiQgn_prop_cmail_action_delete_mask ) ); // FsEActionMenuDelete + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_indi_cmail_calendar_tracking_accept, EMbmFreestyleemailuiQgn_indi_cmail_calendar_tracking_accept_mask ) ); // FsEActionMenuAccept + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_indi_cmail_calendar_tracking_tentative, EMbmFreestyleemailuiQgn_indi_cmail_calendar_tracking_tentative_mask ) ); // FsEActionMenuTentative + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_indi_cmail_calendar_tracking_reject, EMbmFreestyleemailuiQgn_indi_cmail_calendar_tracking_reject_mask ) ); // FsEActionMenuDecline + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_indi_cmail_calendar_delete, EMbmFreestyleemailuiQgn_indi_cmail_calendar_delete_mask ) ); // FsEActionMenuDecline + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_mark_read, EMbmFreestyleemailuiQgn_prop_cmail_action_mark_read_mask ) ); // FsEActionMenuMarkRead + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_mark_unread, EMbmFreestyleemailuiQgn_prop_cmail_action_mark_unread_mask ) ); // FsEActionMenuMarkUnread + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_call, EMbmFreestyleemailuiQgn_prop_cmail_action_call_mask ) ); // FsEActionMenuCall + // video call + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_call_video, EMbmFreestyleemailuiQgn_prop_cmail_action_call_video_mask ) ); // FsEActionMenuCallVideo + // + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_create_msg, EMbmFreestyleemailuiQgn_prop_cmail_action_create_msg_mask ) ); // FsEActionMenuCreateMessage + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_email, EMbmFreestyleemailuiQgn_prop_cmail_action_email_mask) ); // FsEActionMenuCreateEmail + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_contact_detail, EMbmFreestyleemailuiQgn_prop_cmail_action_contact_detail_mask ) ); // FsEActionMenuContactDetails + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_add_to_contacts, EMbmFreestyleemailuiQgn_prop_cmail_action_add_to_contacts_mask ) ); // FsEActionMenuAddToContacts + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_remote_lookup, EMbmFreestyleemailuiQgn_prop_cmail_action_remote_lookup_mask ) ); // FsEActionMenuRemoteLookup + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_move_msg, EMbmFreestyleemailuiQgn_prop_cmail_action_move_msg_mask ) ); // FsEActionMenuMove + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_move_to_drafts, EMbmFreestyleemailuiQgn_prop_cmail_action_move_to_drafts_mask ) ); // FsEActionMenuMoveToDrafts + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_menu_browserng, EMbmFreestyleemailuiQgn_menu_browserng_mask ) ); // FsEActionMenuOpenInWeb + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_menu_intranet, EMbmFreestyleemailuiQgn_menu_intranet_mask ) ); // FsEActionMenuOpenInIntranet + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_wml_bookmark, EMbmFreestyleemailuiQgn_prop_cmail_wml_bookmark_mask ) ); // FsEActionMenuBookmark + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_open, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_open_mask ) ); // FsEActionAttachmentOpen + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_download, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_download_mask ) ); // FsEActionAttachmentDownload + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_cancel_download, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_cancel_download_mask ) ); // FsEActionAttachmentCancelDownload + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_save, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_save_mask ) ); // FsEActionAttachmentSave + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_add, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_add_mask ) ); // FsEActionAttachmentAdd + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_delete, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_delete_mask ) ); // FsEActionAttachmentRemove + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_view_all, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_view_all_mask ) ); // FsEActionAttachmentViewAll + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_download_all, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_download_all_mask ) ); // FsEActionAttachmentDownloadAll + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_cancel_all, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_cancel_all_mask ) ); // FsEActionAttachmentCancelAllDownloads + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_save_all, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_save_all_mask ) ); // FsEActionAttachmentSaveAll + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_delete_all, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_delete_all_mask ) ); // FsEActionAttachmentRemoveAll + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_delete, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_delete_mask ) ); // FsEActionAttachmentClearFetchedContent + iIconArray.AppendL( CreateIconL( EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_delete, EMbmFreestyleemailuiQgn_prop_cmail_action_attachment_list_options_delete_mask ) ); // FsEActionAttachmentRemoveUnfetchedAttachment +// + } + +CGulIcon* CFSEmailUiActionMenu::CreateIconL( TInt aBitmapId, TInt aMaskId ) + { + FUNC_LOG; + // Define default icon object + CFbsBitmap* iconBitmap; + CFbsBitmap* iconMaskBitmap; + TSize defaultIconSize(30,30); + + // Create "CALL" Item + AknIconUtils::CreateIconLC(iconBitmap, iconMaskBitmap, iIconFilePath, aBitmapId, aMaskId ); + AknIconUtils::SetSize(iconBitmap, defaultIconSize); + AknIconUtils::SetSize(iconMaskBitmap, defaultIconSize); + CGulIcon* icon = CGulIcon::NewL(iconBitmap, iconMaskBitmap); + CleanupStack::Pop(2); + return icon; + } + +///////////////////////////////////////////////////////////////////////////////// +// GENERIC TIMER +// + +// ----------------------------------------------------------------------------- +// CFSEmailUiGenericTimer::NewL +// NewL function. Returns timer object. +// ----------------------------------------------------------------------------- +// +CFSEmailUiGenericTimer* CFSEmailUiGenericTimer::NewL( + MFSEmailUiGenericTimerCallback* aCallback, + const TInt aPriority ) + { + FUNC_LOG; + CFSEmailUiGenericTimer* self = NewLC( aCallback, aPriority ); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CFSEmailUiGenericTimer::NewL +// NewL function. Returns timer object. +// ----------------------------------------------------------------------------- +// +CFSEmailUiGenericTimer* CFSEmailUiGenericTimer::NewLC( + MFSEmailUiGenericTimerCallback* aCallback, + const TInt aPriority ) + { + FUNC_LOG; + CFSEmailUiGenericTimer* self = new (ELeave) CFSEmailUiGenericTimer( aCallback, aPriority ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CFSEmailUiGenericTimer::NewL +// NewL function. Returns timer object. +// ----------------------------------------------------------------------------- +// +void CFSEmailUiGenericTimer::ConstructL() + { + FUNC_LOG; + CTimer::ConstructL(); + CActiveScheduler::Add( this ); + } + +// ----------------------------------------------------------------------------- +// CFSEmailUiGenericTimer::~CFSEmailUiGenericTimer +// D'tor +// ----------------------------------------------------------------------------- +// +CFSEmailUiGenericTimer::~CFSEmailUiGenericTimer() + { + FUNC_LOG; + Cancel(); + iCallback = NULL; + } + +// ----------------------------------------------------------------------------- +// CFSEmailUiGenericTimer::CFSEmailUiGenericTimer +// C'tor +// ----------------------------------------------------------------------------- +// +CFSEmailUiGenericTimer::CFSEmailUiGenericTimer( + MFSEmailUiGenericTimerCallback* aCallback, + const TInt aPriority ) + : CTimer( aPriority ), + iCallback( aCallback ) + { + } + +// ----------------------------------------------------------------------------- +// CFSEmailUiGenericTimer::RunL +// Timer trigger function. +// ----------------------------------------------------------------------------- +// +void CFSEmailUiGenericTimer::RunL() + { + FUNC_LOG; + if ( iCallback ) + { + iCallback->TimerEventL( this ); + } + } + +// ----------------------------------------------------------------------------- +// CFSEmailUiGenericTimer::Start +// Timer starting function. +// ----------------------------------------------------------------------------- +// +void CFSEmailUiGenericTimer::Start( TInt aInterval ) + { + FUNC_LOG; + Cancel(); + if( aInterval < 0 ) + { + aInterval = KGenericTimerDefaultInterval; + } + After( TTimeIntervalMicroSeconds32( aInterval * 1000 ) ); + } + +// ----------------------------------------------------------------------------- +// CFSEmailUiGenericTimer::Stop +// Timer stopping function +// ----------------------------------------------------------------------------- +// +void CFSEmailUiGenericTimer::Stop() + { + FUNC_LOG; + Cancel(); + } + +TKeyResponse CFSEmailUiCallDialog::OfferKeyEventL(const TKeyEvent &aKeyEvent, TEventCode aType) + { + if (aKeyEvent.iScanCode == EStdKeyYes ) + { + TKeyEvent newEvent; + newEvent.iScanCode = EStdKeyEnter; + newEvent.iCode = EKeyEnter; + return CAknQueryDialog::OfferKeyEventL(newEvent, aType); + } + else + { + return CAknQueryDialog::OfferKeyEventL(aKeyEvent, aType); + } + } + +