--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/calendarui/controller/src/calenattachmentui.cpp Wed Sep 01 12:32:31 2010 +0100
@@ -0,0 +1,1002 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <aknlistquerydialog.h>
+#include <AiwGenericParam.hrh>
+#include <AiwGenericParam.h>
+#include <AiwVariant.h>
+#include <eikappui.h>
+#include <aknnotewrappers.h>
+#include <AknWaitDialog.h>
+#include <coemain.h>
+#include <calattachment.h>
+#include <CalenInterimUtils2.h>
+#include <calencommonui.rsg>
+#include <StringLoader.h> // StringLoader
+#include <DRMHelper.h>
+#include <caf/data.h>
+#include <caf/caf.h>
+#include <calencommandhandler.h>
+#include <calencontext.h>
+#include <calentoolbar.h>
+
+#include "calenattachmentui.h"
+#include "calendarui_debug.h"
+#include "calenattachmentutils.h"
+#include "calencontroller.h"
+#include "calenviewattachmentsdialog.h"
+#include "calendar.hrh"
+#include "calenattachmentmodel.h"
+#include "calenattachmentinfo.h"
+#include "CleanupResetAndDestroy.h"
+#include "calenviewmanager.h"
+
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::NewL
+// 1st phase of construction
+// ----------------------------------------------------------------------------
+//
+CCalenAttachmentUi* CCalenAttachmentUi::NewL(CCalenController& aController)
+ {
+ TRACE_ENTRY_POINT;
+
+ CCalenAttachmentUi* self = new (ELeave) CCalenAttachmentUi(aController);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+
+ TRACE_EXIT_POINT;
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::~CCalenAttachmentUi
+// Destructor
+// ----------------------------------------------------------------------------
+//
+CCalenAttachmentUi::~CCalenAttachmentUi()
+ {
+ TRACE_ENTRY_POINT;
+ delete iTitle;
+ iController.CancelNotifications( this );
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::CCalenAttachmentUi
+// Default constructor
+// ----------------------------------------------------------------------------
+//
+CCalenAttachmentUi::CCalenAttachmentUi(CCalenController& aController)
+: iController(aController), iAttachmentLoadingOn(EFalse),
+iAddAttachmentFromViewer(EFalse),iViewerActive(EFalse)
+ {
+ TRACE_ENTRY_POINT;
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::ConstructL
+// 2nd phase constructor
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::ConstructL()
+ {
+ TRACE_ENTRY_POINT;
+
+ RArray<TCalenNotification> notificationArray;
+ notificationArray.Append(ECalenNotifyEntrySaved);
+ notificationArray.Append(ECalenNotifyEntryDeleted);
+ notificationArray.Append(ECalenNotifyEntryClosed);
+ notificationArray.Append(ECalenNotifyInstanceDeleted);
+ notificationArray.Append(ECalenNotifyMarkedEntryDeleted);
+ notificationArray.Append(ECalenNotifyMultipleEntriesDeleted);
+ //notificationArray.Append(ECalenNotifyDialogClosed);
+ notificationArray.Append(ECalenNotifyAttachmentViewerClosed);
+ iController.RegisterForNotificationsL( this, notificationArray );
+ notificationArray.Reset();
+
+ iAttachmentModel = &iController.AttachmentData();
+ iAttachmentModel->SetObserver(this);
+ iAttachmentAlreadyExists = EFalse;
+ iAttachmentInfoIntialized = EFalse;
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::HandleCommandL
+// Handles the attachement commands
+// ----------------------------------------------------------------------------
+//
+TBool CCalenAttachmentUi::HandleCommandL(const TCalenCommand& aCommand)
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt continueCommand(EFalse);
+ switch(aCommand.Command())
+ {
+ case ECalenAddAttachment:
+ {
+ HandleAddAttachmentL();
+ }
+ break;
+ case ECalenAddAttachmentFromViewer:
+ {
+
+ iAddAttachmentFromViewer = ETrue;
+ HandleAddAttachmentL();
+ }
+ break;
+ case ECalenViewAttachmentList:
+ {
+ DoAttachmentL();
+ }
+ break;
+ case ECalenRemoveAttachment:
+ {
+ CheckForExistingAttachmentsL();
+
+ RPointerArray<CCalenAttachmentInfo> attachmentInfoList;
+ iAttachmentModel->GetAttachmentListL(attachmentInfoList);
+
+ if(!iAddAttachmentFromViewer && (attachmentInfoList.Count()))
+ {
+ iAttachmentModel->Reset();
+ iController.BroadcastNotification(ECalenNotifyAttachmentRemoved);
+ RemoveTemporaryFilesL();
+ }
+ else
+ {
+ iAttachmentModel->DeleteAttachment(0);
+ }
+ attachmentInfoList.Close();
+ }
+ break;
+ default:
+ break;
+ }
+
+ TRACE_EXIT_POINT;
+ return continueCommand;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::CalenCommandHandlerExtensionL
+// Dummy implementation.
+// (other items were commented in a header).
+// ----------------------------------------------------------------------------
+//
+TAny* CCalenAttachmentUi::CalenCommandHandlerExtensionL( TUid /*aExtensionUid*/ )
+ {
+ TRACE_ENTRY_POINT;
+ TRACE_EXIT_POINT;
+ return NULL;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::HandleNotification
+// Handle notifications
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::HandleNotification(const TCalenNotification aNotification)
+ {
+ TRACE_ENTRY_POINT;
+
+ TRAP_IGNORE(DoHandleNotificationL(aNotification));
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::DoHandleNotificationL
+// Handle notifications
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::DoHandleNotificationL(const TCalenNotification aNotification )
+ {
+ TRACE_ENTRY_POINT;
+ switch(aNotification)
+ {
+ case ECalenNotifyEntrySaved:
+ case ECalenNotifyEntryDeleted:
+ case ECalenNotifyInstanceDeleted:
+ {
+ if(!(iAddAttachmentFromViewer))
+ {
+ iAttachmentModel->Reset();
+ }
+ // clear calendar editor's folder
+ RemoveTemporaryFilesL();
+ iAttachmentInfoIntialized = EFalse;
+ }
+ break;
+ case ECalenNotifyEntryClosed:
+ case ECalenNotifyMarkedEntryDeleted:
+ case ECalenNotifyMultipleEntriesDeleted:
+ //case ECalenNotifyDialogClosed:
+ {
+ if(!(iAddAttachmentFromViewer) && !(iAttachmentAlreadyExists))
+ {
+ iAttachmentModel->Reset();
+ }
+ iAttachmentAlreadyExists = EFalse;
+ iAttachmentInfoIntialized = EFalse;
+ }
+ break;
+ case ECalenNotifyAttachmentViewerClosed:
+ {
+ if(iAddAttachmentFromViewer)
+ {
+
+
+ // Do not reset the model if the attachment list has been opened from the editor.
+ if(!iController.IsEditorActive())
+ {
+ // add attachments to the entry being viewed in event viewer
+ AddAttachmentsToEntryL();
+ // clear calendar editor's folder
+ RemoveTemporaryFilesL();
+
+ iAttachmentModel->Reset();
+ }
+
+ iAddAttachmentFromViewer = EFalse;
+
+ // refresh the event view
+ iController.ViewManager().StartActiveStepL();
+ }
+ MCalenToolbar* toolbar = iController.Services().ToolbarOrNull();
+ if(toolbar)
+ {
+ if(iShowToolbar)
+ {
+ toolbar->SetToolbarVisibilityL(ETrue);
+ }
+ iShowToolbar = EFalse;
+ }
+
+ iAttachmentInfoIntialized = EFalse;
+ iViewerActive = EFalse;
+ }
+ break;
+ default:
+ break;
+ }
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::HandleAddAttachmentL
+// Handles the command ECalenAddAttachment
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::HandleAddAttachmentL()
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt selectedIndex(0);
+ CAknListQueryDialog* dlg = new (ELeave) CAknListQueryDialog(&selectedIndex);
+ dlg->PrepareLC( R_ATTACHMENT_LIST_QUERY );
+
+ if(dlg->RunLD())
+ {
+ iSelectedCommand = selectedIndex;
+ switch(selectedIndex)
+ {
+ case ECalenAddImage:
+ {
+ FetchFileL(CCalenAttachmentUtils::EImage);
+ }
+ break;
+ case ECalenAddNote:
+ {
+ FetchFileL(CCalenAttachmentUtils::ENote);
+ }
+ break;
+ case ECalenAddAudio:
+ {
+ FetchFileL(CCalenAttachmentUtils::EAudio);
+ }
+ break;
+ case ECalenAddVideo:
+ {
+ FetchFileL(CCalenAttachmentUtils::EVideo);
+ }
+ break;
+ case ECalenAddOtherFiles:
+ {
+ FetchFileL(CCalenAttachmentUtils::EUnknown);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ else
+ {
+ iController.BroadcastNotification(ECalenNotifyDialogClosed);
+ }
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::FetchFileL
+// For fetching the file from other apps
+// ----------------------------------------------------------------------------
+//
+TBool CCalenAttachmentUi::FetchFileL(
+ CCalenAttachmentUtils::TCalenAttachmentFileType aFetchType)
+ {
+ TRACE_ENTRY_POINT;
+
+
+ CDesCArrayFlat* files = new( ELeave ) CDesC16ArrayFlat(1);
+ CleanupStack::PushL(files);
+
+ TBool fetchOk(EFalse);
+ if(aFetchType == CCalenAttachmentUtils::EUnknown)
+ {
+ TFileName fileName(KNullDesC);
+ // used for fetching any file from the file system
+ if(CCalenAttachmentUtils::FetchAnyFileL( fileName, this ))
+ {
+ fetchOk = ETrue;
+ }
+ }
+ else
+ {
+ // used for fetching media file and notes
+ fetchOk = CCalenAttachmentUtils::FetchFileL( aFetchType, *files,
+ NULL, EFalse, EFalse, this );
+
+
+ if(fetchOk && iSelectedCommand == ECalenAddNote)
+ {
+ AddAttachmentL(files->MdcaPoint(0));
+ }
+ }
+ CleanupStack::PopAndDestroy( files );
+
+ if(!fetchOk)
+ {
+ iController.BroadcastNotification(ECalenNotifyDialogClosed);
+ }
+
+ TRACE_EXIT_POINT;
+ return fetchOk;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::VerifySelectionL
+// Interface for verifying fetched media files selection
+// ----------------------------------------------------------------------------
+//
+TBool CCalenAttachmentUi::VerifySelectionL(const MDesCArray* aSelectedFiles)
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt selectedFilesCount = aSelectedFiles->MdcaCount();
+ for(TInt index=0;index<selectedFilesCount;index++)
+ {
+ RFile file;
+ CEikonEnv* eikonEnv = CEikonEnv::Static();
+ RFs& fs = eikonEnv->FsSession();
+ User::LeaveIfError(fs.ShareProtected());
+ TInt err = file.Open( fs, aSelectedFiles->MdcaPoint(index), EFileRead );
+ file.Close();
+ if( KErrNone != err )
+ {
+ // if any error in opening file then return EFalse
+ return EFalse;
+ }
+ AddAttachmentL(aSelectedFiles->MdcaPoint(index));
+ }
+
+ TRACE_EXIT_POINT;
+
+ return ETrue;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::OkToExitL
+// Get's called when user selects any file from file system through common
+// memory dialogs
+// ----------------------------------------------------------------------------
+//
+TBool CCalenAttachmentUi::OkToExitL( const TDesC& aDriveAndPath, const TEntry& aEntry )
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt length = aDriveAndPath.Length() + aEntry.iName.Length();
+ if(length)
+ {
+ HBufC* filename = HBufC::NewLC( length );
+ TPtr ptr = filename->Des();
+ ptr.Append( aDriveAndPath );
+ ptr.Append( aEntry.iName );
+
+ RFile file;
+ CEikonEnv* eikonEnv = CEikonEnv::Static();
+ RFs& fs = eikonEnv->FsSession();
+ User::LeaveIfError(fs.ShareProtected());
+ TInt err = file.Open( fs, *filename, EFileRead );
+ file.Close();
+ if( KErrNone != err )
+ {
+ // if any error in opening file then return EFalse
+ CleanupStack::PopAndDestroy(filename);
+ return EFalse;
+ }
+
+ AddAttachmentL(*filename);
+
+ CleanupStack::PopAndDestroy(filename);
+ }
+
+ TRACE_EXIT_POINT;
+ return ETrue;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::CheckForExistingAttachmentsL
+// check for already existing attachments from the entry
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::CheckForExistingAttachmentsL()
+ {
+ TRACE_ENTRY_POINT;
+
+ if( iAttachmentInfoIntialized )
+ return;
+
+ MCalenContext& context = iController.Services().Context();
+ TCalLocalUid entryUid = context.InstanceId().iEntryLocalUid;
+
+ if(entryUid) // If it is not for new entry
+ {
+ CCalEntry* entry = iController.Services().EntryViewL(context.InstanceId().iColId)->FetchL(entryUid);
+ CleanupStack::PushL(entry);
+ if(entry)
+ {
+ iAttachmentModel->CheckForExistingAttachmentsL(entry);
+ iAttachmentInfoIntialized = ETrue;
+ }
+ CleanupStack::PopAndDestroy(entry);
+ }
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::NotifyChanges
+// Notify if attachment added or removed
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::NotifyChanges( TCalenAttachmentCommand aCommand,
+ TInt aAttachmentIndex )
+ {
+ TRACE_ENTRY_POINT;
+
+ if(iViewerActive)
+ {
+ iController.ViewManager().SetRepopulation(ETrue);
+ }
+
+ if(aCommand == ECalenAttachmentAdded)
+ {
+ iController.BroadcastNotification(ECalenNotifyAttachmentAdded);
+ }
+ else if(aCommand == ECalenAttachmentRemoved)
+ {
+ TRAP_IGNORE(RemoveAttachmentFromEntryL(aAttachmentIndex));
+ iController.BroadcastNotification(ECalenNotifyAttachmentRemoved);
+ }
+
+ TRACE_ENTRY_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::GetAttachmentFileL
+// Notify if attachment added or removed
+// ----------------------------------------------------------------------------
+//
+RFile CCalenAttachmentUi::GetAttachmentFileL(TInt aIndex)
+ {
+ TRACE_ENTRY_POINT;
+
+ MCalenContext& context = iController.Services().Context();
+ TCalLocalUid entryUid = context.InstanceId().iEntryLocalUid;
+ RFile fileHandle;
+ CCalEntry* entry = iController.Services().EntryViewL(context.InstanceId().iColId)->FetchL(entryUid);
+ CleanupStack::PushL(entry);
+ if(entry)
+ {
+ TInt attachmentCount = entry->AttachmentCountL();
+ if(attachmentCount)
+ {
+ CCalAttachment* attachment = entry->AttachmentL(aIndex);
+ if(attachment->FileAttachment())
+ {
+ attachment->FileAttachment()->LoadBinaryDataL();
+ CleanupClosePushL(fileHandle);
+ attachment->FileAttachment()->FetchFileHandleL(fileHandle);
+ CleanupStack::Pop(&fileHandle);
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(entry);
+
+ TRACE_EXIT_POINT;
+ return fileHandle;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::AddAttachmentL
+// Adds attachments to the model
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::AddAttachmentL(const TDesC& aSourceFilePath)
+ {
+ TRACE_ENTRY_POINT;
+
+ TParsePtrC fileNameParser(aSourceFilePath);
+ TPtrC parsedFileName = fileNameParser.NameAndExt();
+ TBool drmProtected;
+
+ if(!iAttachmentModel->NumberOfItems())
+ {
+ CheckForExistingAttachmentsL();
+ }
+
+ TBool isAlreadyExists = IsDuplicateNameL(parsedFileName);
+ CheckDRMStatusL(aSourceFilePath,drmProtected);
+
+ if(drmProtected || isAlreadyExists)
+ {
+ iAttachmentAlreadyExists = ETrue;
+ iController.BroadcastNotification(ECalenNotifyDialogClosed);
+ return;
+ }
+
+ TFileName destinationfileName;
+ CopyFetchedFilesL( destinationfileName, aSourceFilePath );
+ iAttachmentModel->AddAttachmentL(destinationfileName, destinationfileName);
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::RemoveAttachmentFromEntryL
+// Remove attachments from the entry
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::RemoveAttachmentFromEntryL(TInt aAttachmentIndex)
+ {
+ TRACE_ENTRY_POINT;
+
+ // If user is deleting it from editors, then dont save it now as there is a chance that user discards these
+ // changes. If user saves it, then editors will save these newly deleted attachments.
+ if(iController.IsEditorActive())
+ {
+ return;
+ }
+
+ MCalenContext& context = iController.Services().Context();
+ TCalLocalUid entryUid = context.InstanceId().iEntryLocalUid;
+
+ CCalEntry* entry = iController.Services().EntryViewL(context.InstanceId().iColId)->FetchL(entryUid);
+ CleanupStack::PushL(entry);
+ if(entry)
+ {
+ if(entry->AttachmentCountL())
+ {
+ CCalAttachment* attachment = entry->AttachmentL(aAttachmentIndex);
+ if(attachment)
+ {
+ entry->DeleteAttachmentL(*attachment);
+
+ CCalEntryView* entryView = iController.Services().EntryViewL(context.InstanceId().iColId);
+ CCalenInterimUtils2::StoreL( *entryView, *entry, ETrue );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy(entry);
+
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::AddAttachmentsToEntryL
+// Adds attachments to the entry from event view
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::AddAttachmentsToEntryL()
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt attachmentCount = iAttachmentModel->NumberOfItems();
+ if(attachmentCount)
+ {
+ MCalenContext& context = iController.Services().Context();
+ TCalLocalUid entryUid = context.InstanceId().iEntryLocalUid;
+
+ CCalEntry* entry = iController.Services().EntryViewL(context.InstanceId().iColId)->FetchL(entryUid);
+ CleanupStack::PushL(entry);
+
+ if(entry)
+ {
+ RPointerArray<CCalenAttachmentInfo> attachmentInfoList;
+
+ iAttachmentModel->GetAttachmentListL(attachmentInfoList);
+ for(TInt index=0;index<attachmentCount;index++)
+ {
+ CCalenAttachmentInfo* attachmentInfo = attachmentInfoList[index];
+ // check if attachmentinfo created for new attachment,to avoid adding
+ // the attachments which already exists in the entry
+ if(attachmentInfo->StoreType() == CCalenAttachmentInfo::ECalenNewAttachment)
+ {
+ TParsePtrC fileNameParser(attachmentInfo->SystemFileName());
+ RFile fileHandle = iAttachmentModel->GetAttachmentFileL(index);
+ CleanupClosePushL(fileHandle);
+ TInt aSize;
+ TInt error = fileHandle.Size(aSize);
+ HBufC8* data = HBufC8::NewLC(aSize);
+ TPtr8 fileData = data->Des();
+ if (error == KErrNone)
+ {
+ TInt readingError = fileHandle.Read(fileData,aSize);
+ if(readingError == KErrNone)
+ {
+ CCalAttachment* attachment = CCalAttachment::NewFileL(data);
+ CleanupStack::Pop(data);
+ CleanupStack::PushL(attachment);
+
+ // sets the label for the attachment
+ attachment->SetLabelL(fileNameParser.NameAndExt());
+ // sets mime type for the attachment
+ attachment->SetMimeTypeL(attachmentInfo->DataType().Des8());
+ entry->AddAttachmentL(*attachment);
+ CleanupStack::Pop(attachment);
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(data);
+ }
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy(data);
+ }
+ CleanupStack::PopAndDestroy(&fileHandle);
+ }
+ }
+
+ attachmentInfoList.Close();
+
+ if(!iController.IsEditorActive())
+ {
+ CCalEntryView* entryView = iController.Services().EntryViewL(context.InstanceId().iColId);
+ CCalenInterimUtils2::StoreL( *entryView, *entry, ETrue );
+ }
+ }
+ CleanupStack::PopAndDestroy(entry);
+ }
+ TRACE_EXIT_POINT;
+ }
+
+// ----------------------------------------------------------------------------
+// CCalenAttachmentUi::CopyFetchedFilesL
+// Copy fetched files in to temporary dir,adding the attachment to the entry
+// will move the file from temporary to symbian calendar db
+// ----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::CopyFetchedFilesL( TFileName& aTempPath,
+ const TDesC& aSourceFilePath)
+ {
+ TRACE_ENTRY_POINT;
+
+ TParsePtrC fileNameParser(aSourceFilePath);
+ TFileName destinationfilePath;
+ const TDesC& destinatiofileName = fileNameParser.NameAndExt();
+ CCalenAttachmentUtils::GetCalenEditorTempPath( destinationfilePath,
+ &destinatiofileName );
+ aTempPath.Append(destinationfilePath);
+
+ CFileMan* fileManager = CFileMan::NewL(CEikonEnv::Static()->FsSession());
+ CleanupStack::PushL(fileManager);
+ fileManager->Copy( aSourceFilePath, destinationfilePath, CFileMan::ERecurse );
+ CleanupStack::PopAndDestroy(fileManager);
+
+ TRACE_EXIT_POINT;
+ }
+
+// ------------------------------------------------------------------------------
+// void CCalenAttachmentUi::DoAttachmentL()
+// Opens an attachment dialog.
+// ------------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::DoAttachmentL()
+ {
+ TRACE_ENTRY_POINT;
+
+ CheckForExistingAttachmentsL();
+ //Check if iTitle allready exists
+ if(!iTitle)
+ {
+ iTitle = CCoeEnv::Static()->AllocReadResourceLC(
+ R_VIEWER_TITLE_ATTACHMENTS);
+
+ CleanupStack::Pop(iTitle);
+ }
+
+ CCalenAttachmentModel* attmodel = iAttachmentModel;
+
+ iAttachmentdlg = CCalenViewAttachmentsDialog::NewL(*iTitle,*attmodel,iController );
+
+ // Hide the toolbar before we display settings menu
+ MCalenToolbar* toolbar = iController.Services().ToolbarOrNull();
+
+ if(toolbar&&toolbar->IsVisible()&& !iController.IsEditorActive())
+ {
+ toolbar->SetToolbarVisibilityL(EFalse);
+ iShowToolbar = ETrue;
+ }
+ //To make sure we are viewer, so for delete attachment, notification will be issued
+ // only when viewer is closed (EFalse)
+ iViewerActive = ETrue;
+
+ // safe to call LD even as a member variable, since sets itself to NULL when deleting
+ iAttachmentdlg->ExecuteLD(R_CALEN_ATTACHMENT_DIALOG); // CSI: 50 # see comment above
+
+
+ if(iAttachmentLoadingOn)
+ {
+ ShowWaitNoteL( ETrue );
+ if ( iWaitDialog )
+ {
+ iWaitDialog->SetCallback( this );
+ }
+ }
+ else
+ {
+ //Update attachment models fetched-flags
+ //if we are not currently loading attachments.
+ if(iAttachmentdlg)
+ {
+ iAttachmentdlg->UpdateAttachmentsFetchFlags();
+ }
+
+ }
+
+ // Dialer is always enabled in attachment dialog
+ // SetDialerEnabled( ETrue );
+ TRACE_EXIT_POINT;
+ }
+
+// ------------------------------------------------------------------------------
+// CCalenAttachmentUi::ShowWaitNoteL()
+// Shows wait note
+// ------------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::ShowWaitNoteL( TBool aCanCancel )
+ {
+ TRACE_ENTRY_POINT;
+
+ if (!iWaitDialog)
+ {
+ // safe to call LD even as a member variable,
+ // since sets itself to NULL when deleting
+ iWaitDialog = new(ELeave)CAknWaitDialog(
+ (reinterpret_cast<CEikDialog**>( &iWaitDialog )), ETrue);
+
+ // safe to call LD even as a member variable, since sets itself to NULL when deleting
+ iWaitDialog->ExecuteLD(R_VIEWER_WAIT_OPEN_DIALOG_NOTE); // CSI: 50 # see comment above
+ iWaitDialog->MakePanelButtonVisible( EAknSoftkeyCancel, aCanCancel );
+ }
+ TRACE_EXIT_POINT;
+ }
+
+// ------------------------------------------------------------------------------
+// From MProgressDialogCallback called when wait note dismissed
+// called when dialog is dismissed
+// ------------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::DialogDismissedL( TInt aButtonId )
+ {
+ TRACE_ENTRY_POINT;
+
+ if ( aButtonId == EAknSoftkeyCancel )
+ {
+ delete iAttachmentdlg;
+ iAttachmentdlg = NULL;
+ iWaitDialog = NULL;
+ }
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenAttachmentUi::CheckDRMStatus()
+// -----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::CheckDRMStatusL( const TDesC& aFileName,TBool& aProtection )
+ {
+ TRACE_ENTRY_POINT;
+
+ RFile file;
+ file.Close();
+ RFs& fs = CEikonEnv::Static()->FsSession();
+ TInt err1 = file.Open( fs, aFileName, EFileRead | EFileShareReadersOnly );
+ CleanupClosePushL( file );
+
+ CContent* content = CContent::NewLC(file);
+ TInt isDRMProtected = 0;
+
+ //Check if file is drm protected. If not no need for further checks.
+ User::LeaveIfError(content->GetAttribute(EIsProtected, isDRMProtected));
+ if (isDRMProtected)
+ {
+ aProtection = ETrue;
+
+ //DRM protected file: can't attach the DRM protected file
+ HBufC* cannotAttach = StringLoader::LoadLC(
+ R_QTN_CALEN_INFO_CANNOT_OPEN, CCoeEnv::Static() );
+ CAknInformationNote* note = new ( ELeave ) CAknInformationNote(ETrue);
+ note->ExecuteLD( *cannotAttach );
+ CleanupStack::PopAndDestroy( cannotAttach );
+ }
+ else
+ {
+ aProtection = EFalse;
+ }
+ CleanupStack::PopAndDestroy(content);
+ CleanupStack::PopAndDestroy(&file);
+
+ TRACE_EXIT_POINT;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenAttachmentUi::IsDuplicateNameL()
+// Compares the name of the already attached and currently
+// attached attachment names.
+// returns ETrue if match is found, EFalse otherwise.
+// -----------------------------------------------------------------------------
+//
+TBool CCalenAttachmentUi::IsDuplicateNameL(const TDesC& aSelectedFile)
+ {
+ TRACE_ENTRY_POINT;
+
+ TInt attachmentCount = iAttachmentModel->NumberOfItems();
+ TBool matchNotFound(ETrue);
+ if(attachmentCount>0)
+ {
+ RPointerArray<CCalenAttachmentInfo> attachmentInfoList;
+ iAttachmentModel->GetAttachmentListL(attachmentInfoList);
+
+ TParsePtrC fileNameParser(aSelectedFile);
+ TPtrC parsedFileName = fileNameParser.Ext();
+ for(TInt index=0; index<attachmentCount && matchNotFound; index++)
+ {
+ TParsePtrC fileNameParser(attachmentInfoList[index]->FileName());
+ TPtrC parsedFileName = fileNameParser.NameAndExt();
+ matchNotFound = aSelectedFile.Compare(parsedFileName);
+ }
+ attachmentInfoList.Close();
+ }
+
+ if(!matchNotFound)
+ {
+ //though attachment is aleady attached to this entry, show the info note for this info.
+ CAknInformationNote* note = new ( ELeave ) CAknInformationNote(ETrue);
+ HBufC* cannotAttach = StringLoader::LoadLC(
+ R_QTN_CALEN_INFO_ALREADY_ATTACHED, CCoeEnv::Static() );
+ note->ExecuteLD( *cannotAttach );
+ CleanupStack::PopAndDestroy( cannotAttach );
+ }
+
+
+ TRACE_EXIT_POINT;
+ return !matchNotFound;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenAttachmentUi::CompareContentOfTextFiles()
+// Compares the binary data of already attached and currently selected text file.
+// -----------------------------------------------------------------------------
+//
+TBool CCalenAttachmentUi::CompareContentOfTextFilesL( const TDesC& aSelectedFile,
+ const TDesC& aAlreadyAttachedFile)
+ {
+ TRACE_ENTRY_POINT;
+
+ TBool matchFound(EFalse);
+ //get the binary data of both the files and compare.
+ RFile fileHandle;
+ CEikonEnv* eikonEnv = CEikonEnv::Static();
+ RFs& fs = eikonEnv->FsSession();
+ User::LeaveIfError(fs.ShareProtected());
+
+ //for newly selected file
+ TInt aSelectedFileSize;
+ TInt openErrForSelectedFile = fileHandle.Open(fs, aSelectedFile, EFileWrite);
+ if( KErrNone != openErrForSelectedFile )
+ {
+ //Not Handling the Error case as of now.
+ }
+
+ TInt sizeErrorForSelectedFile = fileHandle.Size(aSelectedFileSize);
+ HBufC8* aNewlySelectedFile = HBufC8::NewLC(aSelectedFileSize);
+ TPtr8 aSelectedFileData = aNewlySelectedFile->Des();
+
+ // create one more file handle, because for
+ // the same file its coming as "Already in use".
+ RFile fileHandleForAlreadySelected;
+
+ // for already selected file
+ TInt aAlreadySelectedFileSize;
+ TInt openErrorForAlreadyAttachedFile =
+ fileHandleForAlreadySelected.Open(fs, aAlreadyAttachedFile, EFileWrite);
+
+ if( KErrNone != openErrorForAlreadyAttachedFile )
+ {
+ fileHandleForAlreadySelected.Close();
+ openErrorForAlreadyAttachedFile =
+ fileHandleForAlreadySelected.Open(fs, aAlreadyAttachedFile, EFileWrite);
+ }
+
+ TInt sizeErrorForAlreadyAttachedFile =
+ fileHandleForAlreadySelected.Size(aAlreadySelectedFileSize);
+ HBufC8* aAttachedFile = HBufC8::NewLC(aAlreadySelectedFileSize);
+ TPtr8 aAttachedFileData = aAttachedFile->Des();
+
+ if(!(aAttachedFileData.Compare(aSelectedFileData)))
+ {
+ matchFound=ETrue;
+ }
+
+ CleanupStack::Pop(2);
+ CleanupClosePushL(fileHandle);
+ CleanupStack::PopAndDestroy(&fileHandle);
+
+ TRACE_EXIT_POINT;
+ return matchFound;
+ }
+
+// -----------------------------------------------------------------------------
+// CCalenAttachmentUi::RemoveTemporaryFiles()
+// removes the temporary files, those we have added to temp path.
+// -----------------------------------------------------------------------------
+//
+void CCalenAttachmentUi::RemoveTemporaryFilesL()
+ {
+ TRACE_ENTRY_POINT;
+
+ CEikonEnv* eikonEnv = CEikonEnv::Static();
+ CFileMan* fileMan = CFileMan::NewL( eikonEnv->FsSession() );
+ CleanupStack::PushL( fileMan );
+
+ // delete files from temp directory.
+ TFileName temppath;
+ CCalenAttachmentUtils::GetCalenEditorTempPath( temppath );
+ fileMan->Delete( temppath );
+ CleanupStack::PopAndDestroy( fileMan );
+
+ TRACE_EXIT_POINT;
+ }
+// end of file