// Copyright (c) 1998-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:

// MODULE - Message Type Module

// 

//

// Generic includes

#include <coemain.h>	// CCoeEnv

#include <bautils.h>	// BaflUtils

#include <basched.h>	// KErrExtended

// Messaging includes

#include <msvreg.h>

#include <msvuids.h>

#include <msvruids.h>

// Specific includes

#include "MTMUIBAS.H"

#include "MTUIPAN.H"

//

// CBaseMtmUi - MTMUi base API (public methods)  //

//

EXPORT_C CBaseMtmUi::~CBaseMtmUi()

/** Destructor.

Cleans up the base class. CBaseMtmUi-derived objects must be deleted by client 

applications when they are no longer required. 

Derived classes can implement a destructor to do any additional clean up tasks 

that they require. */

	{

	iRegisteredMtmDll.ReleaseLibrary();

	if (iResourceFileOffset)

		iCoeEnv->DeleteResourceFile(iResourceFileOffset);

	}

EXPORT_C void CBaseMtmUi::SetPreferences(TUint aFlags)

/** Sets flags that communicate the MTM's preferences to the application UI.

@param aFlags Bitmask of preference flags */

	{

	iFlags = aFlags;

	}

EXPORT_C TUint CBaseMtmUi::Preferences() const

/** Gets flags that communicate the MTM's preferences to the application UI.

@return Bitmask of preference flags */

	{

	return iFlags;

	}

EXPORT_C TUid CBaseMtmUi::Type() const

/** Gets the Type UID of the message type associated with the User Interface MTM.

@return UID of the message type associated with the MTM */

	{

	return iBaseMtm.Type();

	}

EXPORT_C CBaseMtm& CBaseMtmUi::BaseMtm() const

/** Gets a reference to the Client-side MTM that requested this object.

@return Client-side MTM that requested this object */

	{

	return iBaseMtm;

	}

//

// --- Functions NOT dependent on the current context ---

//

EXPORT_C CMsvOperation* CBaseMtmUi::CreateL(const TMsvEntry& aEntry, CMsvEntry& aParent, TRequestStatus& aStatus)

// Default implementation simply delegates to the message server

/** Creates a new entry as a child. 

Typically, after creating the entry, the function would launch a suitable interface, 

such as a message editor, for the user to edit the new entry.

The returned CMsvOperation object completes when creation is complete (for 

example, when the message editor application is closed).

Requirements:

The default implementation simply calls aParent.CreateL() to create the entry. 

If creating entries is not supported, implementations should leave with KErrNotSupported. 

Otherwise, implementations should:

1. check aEntry.iType.iUid to ensure that they can create the requested type 

of entry and leave with code KErrNotSupported if they cannot

2. return a CMsvOperation-derived object to provide asynchronous control and 

monitoring of the operation

3. for messages, launch a suitable editor application developed for the message 

type.

@param aEntry The data to be copied into the new entry 

@param aParent The parent of the new entry 

@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported The requested type of entry cannot be created 

@leave Other Dependent on implementation 

@return If successful, this is an asynchronously completing create operation. 

If failed, this is a completed operation, with status set to the relevant 

error code. */

	{

	return aParent.CreateL(aEntry, aStatus);

	}

//

// --- Deletion ---

// --- Deletes entries from the current context, which must be a folder or service of the relevant MTM ---

//

EXPORT_C CMsvOperation* CBaseMtmUi::DeleteFromL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

/** Deletes a selection of entries owned by the current context. 

The current context must be a folder or service of the relevant MTM. The returned CMsvOperation 

object completes when deleting is complete. 

Requirements:

The default implementation simply calls CMsvEntry::DeleteL() to delete the 

entries. Implementations can override this to provide any additional checking 

or user interaction. If deleting entries is not supported, implementations 

should leave with KErrNotSupported.

Where this function is implemented, it should return a CMsvOperation-derived 

object to provide asynchronous control and monitoring of the operation.

@param aSelection Selection of message entries 

@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported The User Interface MTM does not support delete operations, 

or deleting is inappropriate to the current context 

@leave Other Dependent on implementation 

@return If successful, this is an asynchronously completing delete operation. 

If failed, this is a completed operation, with status set to the relevant 

error code. */

	{

	__ASSERT_DEBUG(aSelection.Count(), Panic(EMtuiEmptySelection));

//	const TMsvEntry& context=BaseMtm().Entry().Entry();

//@	__ASSERT_ALWAYS(context.iType.iUid==KUidMsvServiceEntryValue || context.iType.iUid==KUidMsvFolderEntryValue, Panic(EMtuiContextNotFolderOrService));

	return BaseMtm().Entry().DeleteL(aSelection, aStatus);

	}

EXPORT_C CMsvOperation* CBaseMtmUi::UnDeleteFromL(const CMsvEntrySelection& /*aSelection*/, TRequestStatus& /*aStatus*/)

/** Undeletes the specified selection.

The default implementation leaves with KErrNotSupported.

@param aSelection Selection of message entries 

@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported The User Interface MTM does not support undelete operations, 

or undeleting is inappropriate to the current context 

@leave Other Dependent on implementation 

@return If successful, this is an asynchronously completing undelete operation. 

If failed, this is a completed operation, with status set to the relevant 

error code. */

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

//

// --- Deletes service, which need not be the current context ---

EXPORT_C CMsvOperation* CBaseMtmUi::DeleteServiceL(const TMsvEntry& aService, TRequestStatus& aStatus)

/** Deletes a specified service entry. 

This entry does not have to be the current context. The usual behaviour is to remove the 

service settings, disabling further use of that service. The returned CMsvOperation 

object completes when deleting is complete.

Requirements:

The default implementation calls CMsvEntry::DeleteL() to delete the entry. 

Implementations can override this to provide any additional checking or user 

interaction. If deleting services is not supported, implementations should 

leave with KErrNotSupported.

Where this function is implemented, it should return a CMsvOperation-derived 

object to provide asynchronous control and monitoring of the operation.

@param aService Service to delete 

@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported This User Interface MTM does not support delete service 

operations 

@leave Other Dependent on implementation 

@return If successful, this is an asynchronously completing delete operation. 

If failed, this is a completed operation, with status set to the relevant 

error code. */

	{

	__ASSERT_DEBUG(aService.iType.iUid==KUidMsvServiceEntryValue, Panic(EMtuiEntryNotService));

	CMsvEntry* parent=Session().GetEntryL(aService.Parent());

	CleanupStack::PushL(parent);

	CMsvOperation* deleteoperation=parent->DeleteL(aService.Id(), aStatus);

	CleanupStack::PopAndDestroy();// parent

	return deleteoperation;

	}

//

// --- Copy and move functions ---

// --- Context should be set to folder or entry of this MTM ---

// --- Default implementations simply call the relevant CMsvEntry functions ---

//

EXPORT_C CMsvOperation* CBaseMtmUi::CopyToL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

// Copies entries in that selection to the current context

// All entries in the selection must have the same parent

/** Copies an entry selection to a remote service. 

All entries in the selection must have the same parent. The current context must be the MTM folder or service 

to which to copy. The returned CMsvOperation object completes when copying 

the entries is complete.

The usual result of this function is to send messages. The exact behaviour varies 

between MTMs: for example, a Fax MTM would transmit a fax when asked to copy a fax 

from a local folder to a fax service. 

Requirements:

The default implementation calls CMsvEntry::CopyL() to do the copy. If message 

copying is not supported, implementations should leave with KErrNotSupported.

Where this function is implemented, it should return a CMsvOperation-derived 

object to provide asynchronous control and monitoring of the operation.

@param aSelection Selection of message entries 

@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported The User Interface MTM does not support copy to operations 

@leave Other Dependent on implementation 

@return If successful, this is an asynchronously completing copy operation. 

If failed, this is a completed operation, with status set to the relevant 

error code. */

	{

	__ASSERT_DEBUG(aSelection.Count(), Panic(EMtuiEmptySelection));

	const TMsvEntry& context=BaseMtm().Entry().Entry();

	__ASSERT_ALWAYS(context.iType.iUid==KUidMsvServiceEntryValue || context.iType.iUid==KUidMsvFolderEntryValue, Panic(EMtuiContextNotFolderOrService));

	CMsvEntry* sourceEntry=Session().GetEntryL(aSelection.At(0));

	CleanupStack::PushL(sourceEntry);

	CMsvOperation* op=sourceEntry->CopyL(aSelection, context.Id(), aStatus);

	CleanupStack::PopAndDestroy();// sourceEntry

	return op;

	}

EXPORT_C CMsvOperation* CBaseMtmUi::MoveToL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)

/** Moves an entry selection to a remote service. 

All entries in the selection must have the same parent. The current context must be the 

MTM folder or service to which to move the entries. The returned CMsvOperation object completes 

when moving the entries is complete.

The usual result of this function is to send messages, in a similar way to 

CopyToL(). The difference is that CopyToL() does not remove the original entries. 

The exact behaviour varies between MTMs, as described for CopyToL().

Requirements:

The default implementation calls CMsvEntry::MoveL() to do the move. Implementations 

are likely to be similar to those for CopyToL(), and may indeed share code.

If an MTM does not support message moving, then it should leave with value 

KErrNotSupported.

Where this function is implemented, it should return a CMsvOperation-derived 

object to provide asynchronous control and monitoring of the operation.

@param aSelection Selection of message entries 

@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported The User Interface MTM does not support move to operations 

@leave Other Dependent on implementation 

@return If successful, this is an asynchronously completing move operation. 

If failed, this is a completed operation, with status set to the relevant 

error code. */

	{

	__ASSERT_DEBUG(aSelection.Count(), Panic(EMtuiEmptySelection));

	const TMsvEntry& context=BaseMtm().Entry().Entry();

	__ASSERT_ALWAYS(context.iType.iUid==KUidMsvServiceEntryValue || context.iType.iUid==KUidMsvFolderEntryValue, Panic(EMtuiContextNotFolderOrService));

	CMsvEntry* sourceEntry=Session().GetEntryL(aSelection.At(0));

	CleanupStack::PushL(sourceEntry);

	CMsvOperation* op=sourceEntry->MoveL(aSelection, context.Id(), aStatus);

	CleanupStack::PopAndDestroy();// sourceEntry

	return op;

	}

EXPORT_C CMsvOperation* CBaseMtmUi::CopyFromL(const CMsvEntrySelection& aSelection, TMsvId aTargetId, TRequestStatus& aStatus)

/** Copies an entry selection from a remote service. 

All entries in the selection 

must have the same parent. The current context must be the MTM folder or service 

from which to copy. The returned CMsvOperation object completes when copying 

the entries is complete.

The usual result of this function is to get messages. It is called when the 

user copies and pastes messages from a remote service. The exact behaviour 

varies between MTMs. 

Requirements:

The default implementation calls CMsvEntry::CopyL() to do the copy. If message 

copying is not supported, implementations should leave with KErrNotSupported.

Where this function is implemented, it should return a CMsvOperation-derived 

object to provide asynchronous control and monitoring of the operation.

@param aSelection Selection of message entries 

@param aTargetId The ID of the entry to own the copies 

@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported The User Interface MTM does not support copy from operations 

@leave Other Dependent on implementation 

@return If successful, this is an asynchronously completing copy operation. 

If failed, this is a completed operation, with status set to the relevant 

error code. */

	{

	__ASSERT_DEBUG(aSelection.Count(), Panic(EMtuiEmptySelection));

	return BaseMtm().Entry().CopyL(aSelection, aTargetId, aStatus);

	}

EXPORT_C CMsvOperation* CBaseMtmUi::MoveFromL(const CMsvEntrySelection& aSelection, TMsvId aTargetId, TRequestStatus& aStatus)

/** Moves an entry selection from a remote service. 

All entries in the selection 

must have the same parent. The current context must be the MTM folder or service 

from which to move. The returned CMsvOperation object completes when moving 

the entries is complete.

The usual result of this function is to get messages, in a similar way to 

CopyFromL(). The difference is that CopyFromL() does not remove the original 

entries. 

Requirements:

The default implementation calls CMsvEntry::MoveL() to do the move. Implementations 

are likely to be similar to those for CopyToL(), and may indeed share code.

If an MTM does not support message moving, then it should leave with value 

KErrNotSupported.

Where this function is implemented, it should return a CMsvOperation-derived 

object to provide asynchronous control and monitoring of the operation.

@param aSelection Selection of message entries 

@param aTargetId The entry ID of the remote service 

@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported The User Interface MTM does not support get operations 

@leave Other Dependent on implementation 

@return If successful, this is an asynchronously completing move operation. 

If failed, this is a completed operation, with status set to the relevant 

error code. */

	{

	__ASSERT_DEBUG(aSelection.Count(), Panic(EMtuiEmptySelection));

	return BaseMtm().Entry().MoveL(aSelection, aTargetId, aStatus);

	}

//

// --- Interpret transfer progress ---

//

EXPORT_C TInt CBaseMtmUi::DisplayProgressSummary(const TDesC8& /*aProgress*/) const

/** Displays a message describing the progress of an operation. 

Requirements:

The default implementation simply returns KErrNotSupported. 

Implementations should unpack the passed aProgress buffer, construct from 

this a suitable message, and display it. The implementation of this function 

should share an understanding of the format of the buffer with the implementations 

of CMsvOperation-derived classes.

@param aProgress Progress information obtained from a call to CMsvOperation::Progress() 

@return A system error code */

	{// Default implementation

	return KErrNotSupported;

	}

EXPORT_C TInt CBaseMtmUi::GetProgress(const TDesC8& /*aProgress*/, TBuf<EProgressStringMaxLen>& /*aReturnString*/, TInt& /*aTotalEntryCount*/,

							 TInt& /*aEntriesDone*/, TInt& /*aCurrentEntrySize*/, TInt& /*aCurrentBytesTrans*/) const

/** Obtains progress information description and statistics. A message client application 

can then display this information to the user. 

Requirements:

The default implementation returns KErrNotSupported.

Implementations should unpack the passed aProgress buffer, and fill in the 

return values appropriately. The implementation of this function should share 

an understanding of the format of the buffer with the implementations of CMsvOperation-derived 

classes.

@param aProgress MTM-specific transfer progress information 

@param aReturnString On return, a string describing the progress status 

@param aTotalEntryCount On return, the total number of entries the operation 

is acting upon 

@param aEntriesDone On return, the number of entries which the operation has 

completed on 

@param aCurrentEntrySize On return, the size of the current entry the operation 

is acting upon 

@param aCurrentBytesTrans On return, the number of bytes of the current entry 

which have been completed 

@return A system error code */

	{// Default implementation

	return KErrNotSupported;

	}

//	

// --- RTTI functions ---

//

EXPORT_C TInt CBaseMtmUi::QueryCapability(TUid aCapability, TInt& aResponse)

/** Queries if the MTM supports a particular capability, specified by a UID. 

For MTM-specific UIDs, see the documentation for the relevant MTM.

Requirements:

The default implementation calls iBaseMtm->QueryCapability() (i.e. the corresponding 

function on the Client-side MTM) to do the query. This is sufficient for many 

implementations. 

However, it is expected that each MTM-specific function is indicated by a 

capability. For example, if the MTM supports a function with UID KMtmUiMessagingXYZ, 

then there might be a capability KMtmUiQueryMessagingXYZ. Therefore, if different 

MTM-specific functions are supported by a User Interface MTM and by the corresponding 

Client-side MTM, this function should be implemented to reflect this.

@param aCapability Capability for which to query 

@param aResponse On return, indicates whether the capability is supported, 

or some other property of the capability.. 

@return KErrNone if successful, KErrNotSupported: aCapability is not a recognised 

value 

@see InvokeAsyncFunctionL()

@see InvokeSyncFunctionL() */

	{

	return iBaseMtm.QueryCapability(aCapability, aResponse);

	}

EXPORT_C void CBaseMtmUi::InvokeSyncFunctionL(TInt aFunctionId, const CMsvEntrySelection& aSelection, TDes8& aParameter)

/** Invokes synchronous protocol-specific operations. For asynchronous operations, 

a similar function, InvokeAsyncFunctionL(), is available.

aSelection and aParameter allow data to be passed to the operation. 

Requirements:

The default implementation calls the corresponding function on the Client-side 

MTM (through iBaseMtm). This is sufficient for many implementations. However, 

there may be certain MTM-specific functions which require interaction with 

the user. These should be implemented here.

@param aFunctionId ID of the requested function 

@param aSelection Selection of message entries. This is used if the operation 

requires message entries to work on. 

@param aParameter Buffer containing input and output parameters. The format 

of this is specific to the operation. 

@leave KErrNotSupported aFunctionId is not a recognised function ID 

@leave Other Dependent on implementation */

	{

	iBaseMtm.InvokeSyncFunctionL(aFunctionId, aSelection, aParameter);

	}

EXPORT_C CMsvOperation* CBaseMtmUi::InvokeAsyncFunctionL(TInt aFunctionId, const CMsvEntrySelection& aSelection, TRequestStatus& aCompletionStatus, 

						TDes8& aParameter)

/**

Invokes asynchronous protocol-specific operations. For synchronous operations, a 

similar function, InvokeSyncFunctionL(), is available.

aSelection and aParameter allow data to be passed to the operation. The TRequestStatus 

and CMsvOperation objects are used as normal to control and monitor the operation.

Requirements:

The default implementation calls the corresponding function on the Client-side MTM 

(through iBaseMtm). This is sufficient for many implementations. However, there may 

be certain MTM-specific functions which require interaction with the user. 

These should be implemented here.

InvokeAsyncFunctionL() should return a CMsvOperation-derived object to provide 

asynchronous control and monitoring of the operation.

@return	If successful, this is an asynchronously completing operation. If failed, 

this is a completed operation, with status set to the relevant error code. 		

@param aFunctionId ID of the requested function 

@param aSelection Selection of message entries. This is used if the operation 

requires message entries to work on. 

@param aParameter Buffer containing input and output parameters. The format 

of this is specific to the operation.

@param aCompletionStatus The request status to be completed when the operation has finished 

@leave KErrNotSupported aFunctionId is not a recognised function ID 

@leave Other Dependent on implementation */

	{

	return iBaseMtm.InvokeAsyncFunctionL(aFunctionId, aSelection, aParameter, aCompletionStatus);

	}

//

// CBaseMtmUi - MTMUi base (protected methods)   //

//

EXPORT_C CBaseMtmUi::CBaseMtmUi(CBaseMtm& aBaseMtm, CRegisteredMtmDll& aRegisteredMtmDll)

	:	iBaseMtm(aBaseMtm), 

		iCoeEnv(CCoeEnv::Static()),

		iRegisteredMtmDll(aRegisteredMtmDll)

/** Constructor, which initialises member variables from the passed arguments.