// 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:
//

#ifdef _DEBUG
#undef _NO_SESSION_LOGGING_
#endif

#include <s32std.h>
#include <txtrich.h>
#include "MSVIDS.H"
#include "MSVUIDS.H"

#include "MSVAPI.H"
#include "MSVCOP.H"
#include "MCLENTRY.H"
#include "MSVPANIC.H"
#include "MSVUTILS.H"

#include <mmsvstoremanager.h>

const TInt KMsvClientEntryArrayGranuality=8;
const TInt KMsvEntryObserverArrayGranuality=4;
const TInt KMsvMtmListGranularity=8;

//**********************************
// CMsvClientEntry
//**********************************

// static 
CMsvClientEntry* CMsvClientEntry::NewLC(const TMsvEntry& aEntry, TMsvClientEntryType aType)
	{
	CMsvClientEntry* self = new(ELeave) CMsvClientEntry(aEntry, aType);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}


CMsvClientEntry::CMsvClientEntry(const TMsvEntry& aEntry, TMsvClientEntryType aType)
:iEntry(aEntry), iType(aType)
	{
	__DECLARE_NAME(_S("CMsvClientEntry"));
	}


CMsvClientEntry::~CMsvClientEntry()
	{
	delete iDescription;
	delete iDetails;
	}

void CMsvClientEntry::ConstructL()
	{
	iDescription = HBufC::NewL(iEntry.iDescription.Length());
	iDescription->Des().Copy(iEntry.iDescription);
	iEntry.iDescription.Set(iDescription->Des());
	iDetails = HBufC::NewL(iEntry.iDetails.Length());
	iDetails->Des().Copy(iEntry.iDetails);
	iEntry.iDetails.Set(iDetails->Des());
	}




//**********************************
// CMsvEntry
//**********************************
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

EXPORT_C CMsvEntry* CMsvEntry::NewL(CMsvSession& aMsvSession, TMsvId aMsvId, const TMsvSelectionOrdering& aOrdering, TBool aChildrenOfAvailableDrives)
/** Creates a new CMsvEntry for the specified entry ID. 

Note that this function does not create a new entry, but simply a new object 
to access an existing entry. To create a new entry, use CreateL().

@param aMsvSession The client’s Message Server session 
@param aMsvId ID of the entry to access 
@param aSortType  The initial sort order of children of the entry, for example, 
when returned by ChildrenL(). The order can be changed later by SetSortTypeL().
@param aChildrenOfAvailableDrives Indicates whether children from all available drives are 
to be fetched during construction of this entry. However, a value of true is valid only
if aMsvId is one of the standard folders, i.e. Inbox, Outbox, Drafts, Sent or Deleted.

@return If the function succeeds, this is a pointer to a newly allocated and initialised object. 
@leave KErrNotFound The requested entry does not exist.
@leave KErrNoMemory A memory allocation failed.
@leave KErrArgument aChildrenOfAvailableDrives is set to true and the requested entry is not 
one of the standard folders, i.e. Inbox, Outbox, Drafts, Sent or Deleted.
*/
    {
    CMsvEntry* self = new(ELeave) CMsvEntry(aMsvSession, aOrdering, aChildrenOfAvailableDrives);
    CleanupStack::PushL(self);
    self->ConstructL(aMsvId);
    CleanupStack::Pop();
    return self;
    }


CMsvEntry::CMsvEntry(CMsvSession& aMsvSession, const TMsvSelectionOrdering& aOrdering, TBool aChildrenOfAvailableDrives)
:iState(EValid), iMsvSession(aMsvSession), iOrdering(aOrdering), iChildrenOfAvailableDrives(aChildrenOfAvailableDrives)
    {
    __DECLARE_NAME(_S("CMsvEntry"));
    }


EXPORT_C void CMsvEntry::SetStandardFolderEntryL(TMsvId aId)
//
// Changes the context to another entry
// If the function leaves, the context is unchanged
//
/** Sets the context to the specified entry while also fetching
children from all available drives. This function can be used to
set the context to only the standard folders i.e. Inbox, Outbox,
Drafts, Sent or Deleted.

If the function leaves, the context is unchanged.

@param aId ID of the message entry which is to become the new context 
@leave KErrNotFound aId could not be found in the index.
@leave KErrArgument aId is not one of the standard folders, i.e. Inbox,
Outbox, Drafts, Sent or Deleted folders.
*/
    {
    __ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpen));

    if (aId==iEntryPtr->Id() && iState==EValid)
        return;
    
    SetEntryNoCheckL(aId, ETrue);
    }



#endif           // #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)


EXPORT_C CMsvEntry* CMsvEntry::NewL(CMsvSession& aMsvSession, TMsvId aMsvId, const TMsvSelectionOrdering& aOrdering)
//
//
//
/** Creates a new CMsvEntry for the specified entry ID. 

Note that this function does not create a new entry, but simply a new object 
to access an existing entry. To create a new entry, use CreateL().

@param aMsvSession The client’s Message Server session 
@param aMsvId ID of the entry to access 
@param aSortType  The initial sort order of children of the entry, for example, 
when returned by ChildrenL(). The order can be changed later by SetSortTypeL(). 
@return If the function succeeds, this is a pointer to a newly allocated and initialised object. 
@leave KErrNotFound The requested entry does not exist 
@leave KErrNoMemory A memory allocation failed 
*/
	{
	CMsvEntry* self = new(ELeave) CMsvEntry(aMsvSession, aOrdering);
	CleanupStack::PushL(self);
	self->ConstructL(aMsvId);
	CleanupStack::Pop();
	return self;
	}


CMsvEntry::CMsvEntry(CMsvSession& aMsvSession, const TMsvSelectionOrdering& aOrdering)
:iState(EValid), iMsvSession(aMsvSession), iOrdering(aOrdering)
//
//
//
	{
	__DECLARE_NAME(_S("CMsvEntry"));
	}


EXPORT_C CMsvEntry::~CMsvEntry()
//
//
//
/** Destructor. 

This cleans up the object. CMsvEntry objects must be deleted by client applications 
when they are no longer required. Note that deleting a CMsvEntry object does 
not delete the context, simply the immediate means of accessing it. */
	{
	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpenOnDestruction2));

	if (iOberserverAdded)
		iMsvSession.RemoveObserver(*this);

	if (iEntries)
		iEntries->ResetAndDestroy();

	delete iEntries;
	delete iSortedChildren;
	delete iObservers;
	delete iMtmList;
	}

void CMsvEntry::ConstructL(TMsvId aId)
//
//
//
	{
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)
    if(iChildrenOfAvailableDrives && !MsvUtils::IsStandardId(aId))
        {
        User::Leave(KErrArgument);
        }
#endif
	iEntries = new (ELeave) CArrayPtrFlat<CMsvClientEntry>(KMsvClientEntryArrayGranuality);
	iMtmList = new(ELeave) CArrayFixFlat<TUid>(KMsvMtmListGranularity);
	iSortedChildren = CMsvEntryArray::NewL(*iMtmList);

	// get the required entry from the server
	CMsvClientEntry* cEntry = DoGetEntryLC(aId, iOwningService);
	cEntry->SetType(EMsvClientContext);
	iEntries->AppendL(cEntry);
	CleanupStack::Pop(); // cEntry
	iEntryPtr = &iEntries->At(0)->Entry();

	// get the children
	DoGetChildrenL();

	// Get the notification sequence number
	iNotifySequence = iMsvSession.Session().NotifySequenceL();

	// get the event notifications from the server
	iMsvSession.AddObserverL(*this);
	iOberserverAdded=ETrue;

#ifndef _NO_SESSION_LOGGING_
	Log(_L("Constructed CMsvEntry on entry %x"), aId); 
#endif
	}

#ifndef _NO_SESSION_LOGGING_
void CMsvEntry::Log(TRefByValue<const TDesC> aFmt, ...)
	{
	VA_LIST list;
	VA_START(list, aFmt);

	// Generate the text
	TBuf<256> buf;
	buf.FormatList(aFmt, list);

	// Write to file
	_LIT(KFormatFile, "CMsvEntry %x: %S");
	iMsvSession.iLog.WriteFormat(KFormatFile, this, &buf);

	// Write to serial
#ifndef _NO_SESSION_LOGGING_SERIAL_
	_LIT(KFormatSerial, "MSGS: CMsvEntry %x: %S");
	RDebug::Print(KFormatSerial, this, &buf);
#endif
	}
#endif

CMsvClientEntry* CMsvEntry::DoGetEntryLC(TMsvId aId, TMsvId& aOwningService)
//
// Gets the entry data from the server and create a CMsvClientEntry around it
//
	{
	TMsvEntry tEntry;
	User::LeaveIfError(iMsvSession.Session().GetEntry(aId, aOwningService, tEntry));
	if (tEntry.iType==KUidMsvRootEntry)
		aOwningService=aId;
	return CMsvClientEntry::NewLC(tEntry, EMsvClientNull);
	}



void CMsvEntry::DoGetChildrenL()
//
// Gets the children of the context and places them in the entries array
// The sorted children pointer array is implicited sorted, as the entries are retrieved
// from the server with the current sort order
//
	{
	__ASSERT_DEBUG(iEntries->Count()==1, PanicServer(EMsvChildEntriesExist1));
	__ASSERT_DEBUG(iSortedChildren->Count()==0, PanicServer(EMsvChildEntriesExist2));

	// get the children from the server - using only the visible flag
	TMsvSelectionOrdering order(KMsvNoGrouping, EMsvSortByNone, iOrdering.ShowInvisibleEntries());
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)
    // If child entries from all drives in the device are to be fetched.
    if(iChildrenOfAvailableDrives)
        {
		User::LeaveIfError(iMsvSession.Session().GetChildrenAll(iEntryPtr->Id(), *iEntries, order));
		}
	else
#endif
        {
        User::LeaveIfError(iMsvSession.Session().GetChildren(iEntryPtr->Id(), *iEntries, order));
		}
	
	// add the children to the sorted pointer list - current context is the first entry
	TInt totalCount=iEntries->Count();
	for (TInt count=1; count<totalCount; count++)
		iSortedChildren->AppendL(&iEntries->At(count)->Entry());

	// sort the children
	iSortedChildren->SortL(iOrdering);
	}


EXPORT_C void CMsvEntry::SetEntryL(TMsvId aId)
//
// Changes the context to another entry
// If the function leaves, the context is unchanged
//
/** Sets the context to the specified entry. 

If the function leaves, the context is unchanged.

@param aId ID of the message entry which is to become the new context 
@leave KErrNotFound aId could not be found in the index */
	{
	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpen));

	if (aId==iEntryPtr->Id() && iState==EValid)
		return;
	
 	SetEntryNoCheckL(aId);
	}

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)
EXPORT_C void CMsvEntry::SetEntryNoCheckL(TMsvId aId, TBool aChildrenOfAvailableDrives /* DEFAULT=EFalse*/)
//
// Changes the context to another entry
// If the function leaves, the context is unchanged
// The function does not check for when the context is already on
// the given TMsvId.
//
/** Sets the context to the specified entry.
Children from all available drives will be fetched depending on the value of
aChildrenOfAvailableDrives.

If the function leaves, the context is unchanged.

@internalTechnology
@param aId ID of the message entry which is to become the new context
@param aChildrenOfAvailableDrives Indicates whether children from all available drives are to
be fetched during construction of this entry. However, a value of true is valid only
if aMsvId is one among TMsvId's of Inbox, Outbox, Drafts, Sent or Deleted folders.
@leave KErrNotFound aMsvId could not be found in the index 
@leave KErrArgument aChildrenOfAvailableDrives is set to true and the requested entry is not
one of the standard folders, i.e. Inbox, Outbox, Drafts, Sent or Deleted. */
    {
    __ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpen));

    if(aChildrenOfAvailableDrives && !MsvUtils::IsStandardId(aId))
        {
        User::Leave(KErrArgument);
        }

    // create new entry array
    CArrayPtrFlat<CMsvClientEntry>* newEntries = new (ELeave) CArrayPtrFlat<CMsvClientEntry>(KMsvClientEntryArrayGranuality);
    CleanupStack::PushL(newEntries);

    // get the new context and place in array
    TMsvId newOwningService;
    CMsvClientEntry* cEntry = DoGetEntryLC(aId, newOwningService);
    cEntry->SetType(EMsvClientContext);
    newEntries->AppendL(cEntry);
    // create new children array
    CMsvEntryArray* newSortedChildren = CMsvEntryArray::NewL(*iMtmList);

    // keep the old arrays
    CArrayPtrFlat<CMsvClientEntry>* oldEntries = iEntries;
    CMsvEntryArray* oldSortedChildren = iSortedChildren;

    TBool oldFlag = iChildrenOfAvailableDrives;
    iChildrenOfAvailableDrives = aChildrenOfAvailableDrives;

    // use new arrays
    CleanupStack::Pop(2); // cEntry, newEntries
    iEntries = newEntries;
    iSortedChildren = newSortedChildren;
    iEntryPtr = &iEntries->At(0)->Entry();

    // get the children and sort accordingly
    TRAPD(leave, DoGetChildrenL(); iNotifySequence = iMsvSession.Session().NotifySequenceL());

    if (leave)
        {
#ifndef _NO_SESSION_LOGGING_
        Log(_L("Failed to SetEntryL to %x with %d"), aId, leave); 
#endif

        // reset the old context
        iChildrenOfAvailableDrives = oldFlag;

        iEntries = oldEntries;
        iSortedChildren = oldSortedChildren;
        iEntryPtr = &iEntries->At(0)->Entry();
        // cleanup
        newEntries->ResetAndDestroy();
        delete newEntries;
        delete newSortedChildren;
        // propogate leave
        User::Leave(leave);
        }
    else
        {
#ifndef _NO_SESSION_LOGGING_
        Log(_L("SetEntryL to %x, sequence %d"), aId, iNotifySequence); 
#endif

        // set the new owning service
        iOwningService = newOwningService;
        // delete the old context
        oldEntries->ResetAndDestroy();
        delete oldEntries;
        delete oldSortedChildren;
        // make sure the state is marked as valid
        iState = EValid;
        }
    }
#else   //#define SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT

EXPORT_C void CMsvEntry::SetEntryNoCheckL(TMsvId aId)
//
// Changes the context to another entry
// If the function leaves, the context is unchanged
// The function does not check for when the context is already on
// the given TMsvId.
//
/** Sets the context to the specified entry. 

If the function leaves, the context is unchanged.

@internalTechnology
@param aId ID of the message entry which is to become the new context 
@leave KErrNotFound aMsvId could not be found in the index */
	{
	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreLeftOpen));

	// create new entry array
	CArrayPtrFlat<CMsvClientEntry>* newEntries = new (ELeave) CArrayPtrFlat<CMsvClientEntry>(KMsvClientEntryArrayGranuality);
	CleanupStack::PushL(newEntries);

	// get the new context and place in array
	TMsvId newOwningService;
	CMsvClientEntry* cEntry = DoGetEntryLC(aId, newOwningService);
	cEntry->SetType(EMsvClientContext);
	newEntries->AppendL(cEntry);
	// create new children array
	CMsvEntryArray* newSortedChildren = CMsvEntryArray::NewL(*iMtmList);

	// keep the old arrays
	CArrayPtrFlat<CMsvClientEntry>* oldEntries = iEntries;
	CMsvEntryArray* oldSortedChildren = iSortedChildren;

	// use new arrays
	CleanupStack::Pop(2); // cEntry, newEntries
	iEntries = newEntries;
	iSortedChildren = newSortedChildren;
	iEntryPtr = &iEntries->At(0)->Entry();

	// get the children and sort accordingly
	TRAPD(leave, DoGetChildrenL(); iNotifySequence = iMsvSession.Session().NotifySequenceL());

	if (leave)
		{
#ifndef _NO_SESSION_LOGGING_
		Log(_L("Failed to SetEntryL to %x with %d"), aId, leave); 
#endif

		// reset the old context
		iEntries = oldEntries;
		iSortedChildren = oldSortedChildren;
		iEntryPtr = &iEntries->At(0)->Entry();
		// cleanup
		newEntries->ResetAndDestroy();
		delete newEntries;
		delete newSortedChildren;
		// propogate leave
		User::Leave(leave);
		}
	else
		{
#ifndef _NO_SESSION_LOGGING_
		Log(_L("SetEntryL to %x, sequence %d"), aId, iNotifySequence); 
#endif

		// set the new owning service
		iOwningService = newOwningService;
		// delete the old context
		oldEntries->ResetAndDestroy();
		delete oldEntries;
		delete oldSortedChildren;
		// make sure the state is marked as valid
		iState = EValid;
		}
	}
#endif
/**
Creates a new child entry owned by the context asynchronously.

Note that all session observers are notified when a new entry is created with 
an EMsvEntriesCreated event (see TMsvSessionEvent). CMsvEntry objects are 
such session observers themselves. When the object receives such a session 
notification, it calls all registered entry observers with a TMsvEntryEvent 
event EMsvNewChildren, passing in the ID of the new child.

If aEntry is not a service entry, then the context must not be set to the root entry and iServiceId field must be defined .
If aEntry is a service entry, then the context must be set to the root entry.

The returned CMsvOperation object completes when creation is complete.

@param	aEntry
Index entry value for the new entry 

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

@leave	KErrArgument aEntry is invalid 

@return 
The operation object controlling the create command. 
*/
EXPORT_C CMsvOperation* CMsvEntry::CreateL(const TMsvEntry& aEntry, TRequestStatus& aStatus)
	{
	return CreateL(aEntry, RProcess().SecureId(), aStatus);
	}
	
/**
Creates a new child entry owned by the context asynchronously. Sets the owner of 
the created entry to process specified by the supplied ID.

Note that all session observers are notified when a new entry is created with 
an EMsvEntriesCreated event (see TMsvSessionEvent). CMsvEntry objects are 
such session observers themselves. When the object receives such a session 
notification, it calls all registered entry observers with a TMsvEntryEvent 
event EMsvNewChildren, passing in the ID of the new child.

If aEntry is not a service entry, then the context must not be set to the root entry and iServiceId field must be defined .
If aEntry is a service entry, then the context must be set to the root entry.

The returned CMsvOperation object completes when creation is complete.

@param	aEntry
Index entry value for the new entry 

@param	aOwnerId
The ID of process that owns the created entry.

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

@leave 	KErrArgument aEntry is invalid 

@return 
The operation object controlling the create command. 
*/
EXPORT_C CMsvOperation* CMsvEntry::CreateL(const TMsvEntry& aEntry, TSecureId aOwnerId, TRequestStatus& aStatus)
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Asynchronous CreateL")); 
#endif

	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

	TMsvEntry entry=aEntry;
	entry.SetParent(iEntryPtr->Id());

	__ASSERT_DEBUG(MsvUtils::ValidEntry(entry, ETrue), PanicServer(EMsvCreatingInvalidEntry));
	if (!MsvUtils::ValidEntry(entry, ETrue))
		User::Leave(KErrArgument);

	CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);
	CleanupStack::PushL(operation);
	User::LeaveIfError(iMsvSession.Session().OperationMtmL(iEntryPtr->Id(), operation->iMtm, operation->iService));
	iMsvSession.Session().CreateEntryL(entry, operation->Id(), aOwnerId, operation->iStatus);
	operation->Start();
	CleanupStack::Pop(); // operation
	return operation;
	}
	

/** 
Creates a new child entry owned by the context synchronously. 

Note that all session observers are notified when a new entry is created with 
an EMsvEntriesCreated event (see TMsvSessionEvent). CMsvEntry objects are 
such session observers themselves. When the object receives such a session 
notification, it calls all registered entry observers with a TMsvEntryEvent 
event EMsvNewChildren, passing in the ID of the new child.

If aEntry is not a service entry, then the context must not be set to the root entry and iServiceId field must be defined .
If aEntry is a service entry, then the context must be set to the root entry.

This function can only be used on local entries.

@param	aEntry
Index entry value for the new entry 

@leave	KErrArgument aEntry is invalid
*/
EXPORT_C void CMsvEntry::CreateL(TMsvEntry& aEntry)
	{
	CreateL(aEntry, RProcess().SecureId());
	}
	
/** 
Creates a new child entry owned by the context synchronously. Sets the owner of 
the created entry to process specified by the supplied ID. 

Note that all session observers are notified when a new entry is created with 
an EMsvEntriesCreated event (see TMsvSessionEvent). CMsvEntry objects are 
such session observers themselves. When the object receives such a session 
notification, it calls all registered entry observers with a TMsvEntryEvent 
event EMsvNewChildren, passing in the ID of the new child.

If aEntry is not a service entry, then the context must not be set to the root entry and iServiceId field must be defined .
If aEntry is a service entry, then the context must be set to the root entry.

This function can only be used on local entries.

@param	aEntry
Index entry value for the new entry

@param	aOwnerId
The ID of process that owns the created entry.

@leave	KErrArgument aEntry is invalid
*/
EXPORT_C void CMsvEntry::CreateL(TMsvEntry& aEntry, TSecureId aOwnerId)
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Synchronous CreateL")); 
#endif
	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService));
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

	TMsvEntry entry=aEntry;
	entry.SetParent(iEntryPtr->Id());

	__ASSERT_DEBUG(MsvUtils::ValidEntry(entry, ETrue), PanicServer(EMsvCreatingInvalidEntry));
	if (!MsvUtils::ValidEntry(entry, ETrue))
		User::Leave(KErrArgument);

	CMsvEntryArray* newSortedChildren = NULL;
	CMsvClientEntry* cEntry = NULL;

	TBool addEntry = entry.Visible() || iOrdering.ShowInvisibleEntries();
	if (addEntry)
		{
		// Create what may be the new child entry if nothing goes wrong
		cEntry = CMsvClientEntry::NewLC(entry, EMsvClientChild);

		// Reserve space for the new entry for later
		iEntries->SetReserveL(iEntries->Count() + 1);

		newSortedChildren = CMsvEntryArray::NewLC(*iMtmList);

		// add the children to the sorted pointer list - current context is the first entry
		TInt totalCount=iEntries->Count();
		for (TInt count=1; count<totalCount; count++)
			newSortedChildren->AppendL(&iEntries->At(count)->Entry());

		// We've created a new sorted child list now so we won't leave later
		newSortedChildren->AppendL(&cEntry->Entry());
		newSortedChildren->SortL(iOrdering);
		}

	TInt id = iMsvSession.OperationId();
	iMsvSession.Session().CreateEntryL(entry, id, aOwnerId);
	iMsvSession.CheckDrive();

    TPckgBuf<TMsvLocalOperationProgress> progressPack;
	User::LeaveIfError(iMsvSession.Session().OperationCompletion(id, progressPack));
	User::LeaveIfError(progressPack().iError);

	// Can't leave after here

	if (addEntry)
		{
		CleanupStack::Pop(); // newSortedChildren
		delete iSortedChildren;
		iSortedChildren = newSortedChildren;

		CleanupStack::Pop(); // cEntry
		iEntries->AppendL(cEntry); // Will not leave because we've reserved space earlier
		cEntry->SetId(progressPack().iId);

		TMsvEntry* ptr = CONST_CAST(TMsvEntry*, iEntryPtr);
		ptr->SetOwner(ETrue);
		}

	aEntry.SetParent(iEntryPtr->Id());
	aEntry.SetId(progressPack().iId);

	// If the entry is a service its service Id is the same as its Id
	// Otherwise it must be a local entry
	// We don't allow synchronous creation of remote entries
	TMsvId serviceId = aEntry.Id();

	aEntry.iServiceId = (aEntry.iType == KUidMsvServiceEntry) ? serviceId : KMsvLocalServiceIndexEntryId;
	}

/** 
Sets the context's index entry to the specified values. The returned CMsvOperation 
object completes when the change is complete.

It is important to note that the state of the context is undefined until the 
observer of the entry has been informed that the entry has been changed, or 
the operation is completed with an error. If the function leaves, the context 
is unchanged.

@param	aEntry 
The new index entry values for the context

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

@leave KErrAccessDenied The entry is locked by another client 

@leave KErrArgument aEntry is invalid or the ID specified in aEntry is not 
the same as the context ID 

@leave KErrNoMemory The operation could not be created or passed to the server 

@return
An operation object controlling the change command
*/
EXPORT_C CMsvOperation* CMsvEntry::ChangeL(const TMsvEntry& aEntry, TRequestStatus& aStatus)
	{
	return ChangeL(aEntry, RProcess().SecureId(), aStatus);
	}

/** 
Sets the context's index entry to the specified values. The returned CMsvOperation 
object completes when the change is complete. Sets the owner of the changed entry 
to process specified by the supplied ID. 

It is important to note that the state of the context is undefined until the 
observer of the entry has been informed that the entry has been changed, or 
the operation is completed with an error. If the function leaves, the context 
is unchanged.

@param	aEntry 
The new index entry values for the context

@param	aOwnerId
The ID of process that owns the changed entry.

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

@leave KErrAccessDenied The entry is locked by another client 

@leave KErrArgument aEntry is invalid or the ID specified in aEntry is not 
the same as the context ID 

@leave KErrNoMemory The operation could not be created or passed to the server 

@return
An operation object controlling the change command
*/
EXPORT_C CMsvOperation* CMsvEntry::ChangeL(const TMsvEntry& aEntry, TSecureId aOwnerId, TRequestStatus& aStatus)
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Asynchronous ChangeL to %x"), aEntry.Id()); 
#endif

	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext, PanicServer(EMsvEntryAlreadyChangingContext));
	__ASSERT_DEBUG(aEntry.Id()==iEntryPtr->Id(), PanicServer(EMsvChangingEntryNotContext));
	__ASSERT_DEBUG(MsvUtils::ValidEntry(aEntry), PanicServer(EMsvChangingToInvalidEntry));

	// can only change the current context
	if (aEntry.Id()!=iEntryPtr->Id() || aEntry.Parent()!=iEntryPtr->Parent() || !MsvUtils::ValidEntry(aEntry))
		User::Leave(KErrArgument);

	// cannot change standard folders
	if (iEntryPtr->StandardFolder())
		User::Leave(KErrAccessDenied);

	// create the operation
	CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);
	CleanupStack::PushL(operation);
	if (iEntryPtr->iType==KUidMsvServiceEntry)
		{
		operation->iMtm = KUidMsvLocalServiceMtm;
		operation->iService = KMsvLocalServiceIndexEntryId;
		}
	else
		User::LeaveIfError(iMsvSession.Session().OperationMtmL(iEntryPtr->Id(), operation->iMtm, operation->iService));
	
	// check that no other entries are type EMsvClientChangedContext
	TInt count=iEntries->Count();
	while (count--)
		{
		if (iEntries->At(count)->Type() == EMsvClientChangedContext)
			{
			delete iEntries->At(count);
			iEntries->Delete(count);
			}
		}

	// create local copy of entry
	TMsvEntry entry=aEntry;

	// check the hidden flags are correct
	entry.SetOwner(iEntryPtr->Owner());
	entry.SetDeleted(iEntryPtr->Deleted());

	// store the new context for after the operation has completed
	CMsvClientEntry* cEntry = CMsvClientEntry::NewLC(entry, EMsvClientChangedContext);
	if (iEntries->Count()==1)
		iEntries->AppendL(cEntry);
	else
		iEntries->InsertL(1, cEntry);

	// start the change operation
	TRAPD(leave, iMsvSession.Session().ChangeEntryL(entry, operation->Id(), aOwnerId, operation->iStatus)); 
	if (leave)
		{
		iEntries->Delete(1);
		CleanupStack::PopAndDestroy(); // operation	& cEntry
		User::Leave(leave);
		}

	operation->Start();
	iState = EInvalidChangingContext;
	CleanupStack::Pop(2); // operation and cEntry
	return operation;
	}

/** 
Sets the context's index entry to the specified values. The function is performed 
synchronously.

This function can only be used on local entries.

@param	aEntry 
The new index entry values for the context 

@leave KErrAccessDenied The entry is locked by another client 

@leave KErrArgument aEntry is invalid or the ID specified in aEntry is not 
the same as the context ID 

@leave KErrNoMemory The operation could not be created or passed to the server
*/
EXPORT_C void CMsvEntry::ChangeL(const TMsvEntry& aEntry)
	{
	ChangeL(aEntry, RProcess().SecureId());
	}

/** 
Sets the context's index entry to the specified values. The function is performed 
synchronously. Sets the owner of the changed entry to process specified by the 
supplied ID. 

This function can only be used on local entries.

@param	aEntry 
The new index entry values for the context 

@param	aOwnerId
The ID of process that owns the changed entry.

@leave KErrAccessDenied The entry is locked by another client 

@leave KErrArgument aEntry is invalid or the ID specified in aEntry is not 
the same as the context ID 

@leave KErrNoMemory The operation could not be created or passed to the server
*/
EXPORT_C void CMsvEntry::ChangeL(const TMsvEntry& aEntry, TSecureId aOwnerId)
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Synchronous ChangeL to %x"), aEntry.Id()); 
#endif

	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext, PanicServer(EMsvEntryAlreadyChangingContext));
	__ASSERT_DEBUG(aEntry.Id()==iEntryPtr->Id(), PanicServer(EMsvChangingEntryNotContext));
	__ASSERT_DEBUG(MsvUtils::ValidEntry(aEntry), PanicServer(EMsvChangingToInvalidEntry));

	// can only change the current context
	if (aEntry.Id()!=iEntryPtr->Id() || aEntry.Parent()!=iEntryPtr->Parent() || !MsvUtils::ValidEntry(aEntry))
		User::Leave(KErrArgument);

	// cannot change standard folders
	if (iEntryPtr->StandardFolder())
		User::Leave(KErrAccessDenied);

	// create local copy of entry
	TMsvEntry entry=aEntry;

	// check the hidden flags are correct
	entry.SetOwner(iEntryPtr->Owner());
	entry.SetDeleted(iEntryPtr->Deleted());

	// store the new context for after the operation has completed
	CMsvClientEntry* cEntry = CMsvClientEntry::NewLC(entry, EMsvClientContext);

	TInt id = iMsvSession.OperationId();
	iMsvSession.Session().ChangeEntryL(aEntry, id, aOwnerId); 

    TPckgBuf<TMsvLocalOperationProgress> progressPack;
	User::LeaveIfError(iMsvSession.Session().OperationCompletion(id, progressPack));
	User::LeaveIfError(progressPack().iError);

	// Cannot leave after this
	delete iEntries->At(0);
	CleanupStack::Pop(); // cEntry
	iEntries->At(0) = cEntry;
	iEntryPtr = &iEntries->At(0)->Entry();
	}

/** 
Update a selection of children to read or Unread asynchronously of the context. 
The returned CMsvOperation object .

@param	aSelection 
The selectio of entry values for the context

@param	aMark 
True : Update selection to UnRead .
False: Update selection to Read . 

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

@leave KErrAccessDenied The entry is locked by another client 

@return
An operation object controlling the change command
*/
EXPORT_C CMsvOperation* CMsvEntry::ChangeL(const CMsvEntrySelection& aSelection,TBool aMark, TRequestStatus& aStatus)
     {
#ifndef _NO_SESSION_LOGGING_
    Log(_L("Asynchronous ChangeL with selection of %d entries"), aSelection.Count()); 
#endif

    __ASSERT_DEBUG(aSelection.Count(), PanicServer(EMsvEmptySelection));

#if defined(_DEBUG)    
     
      TInt aCount = aSelection.Count();
      while (aCount--)
          {
          TMsvEntry aEntry;
          TMsvId aService;
          if (iMsvSession.Session().GetEntry(aSelection.At(aCount), aService, aEntry)==KErrNone)
              {
              __ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext, PanicServer(EMsvEntryAlreadyChangingContext));
              __ASSERT_DEBUG(MsvUtils::ValidEntry(aEntry), PanicServer(EMsvChangingToInvalidEntry));
             
              // can only change the current context
              if (!MsvUtils::ValidEntry(aEntry))
                  User::Leave(KErrArgument);
              }
           }
#endif
      // cannot change standard folders
      if (iEntryPtr->StandardFolder())
          User::Leave(KErrAccessDenied);
  
      //// create the operation
      CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);
      CleanupStack::PushL(operation);
      User::LeaveIfError(iMsvSession.Session().OperationMtmL(aSelection.At(0), operation->iMtm, operation->iService)); 
   
      // start the change operation
	  iMsvSession.Session().ChangeEntriesL(aSelection, aMark, operation->Id(), RProcess().SecureId(), operation->iStatus);
     
      operation->Start();
      iState = EInvalidChangingContext;
      CleanupStack::Pop(1); // operation 
      return operation; 
      }


EXPORT_C CMsvOperation* CMsvEntry::DeleteL(TMsvId aId, TRequestStatus& aStatus)
//
// Deletes a child of the context
//
	/** Deletes a child entry of the context asynchronously.
	
	The delete works recursively through all the descendants. If a child or any 
	descendant is locked by another client or any store or file is open, then 
	that child will not be deleted. Any files and stores associated with the entry 
	are deleted.
	
	The returned CMsvOperation object completes when deletion is complete.
	
	
	@param aId ID of entry to be deleted 
	@param aStatus The request status to be completed when the operation has finished 
	
	@leave KErrNotFound The specified entry was not a child of the context 
	@leave KErrNotSupported If deleting entries from non-current drive
	@return The operation object controlling the deletion command */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Asynchronous DeleteL, entry %x"), aId); 
#endif

	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aId);
	CMsvOperation* operation = DoDeleteL(*selection, aStatus);
	CleanupStack::PopAndDestroy(); // selection
	return operation;
	}



EXPORT_C CMsvOperation* CMsvEntry::DeleteL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)
//
// Deletes a selection containing children of the context
//
/** Deletes child entries of the context asynchronously. 

The delete works recursively through all the descendants. If a child or any 
descendant is locked by another client or any store or file is open, then 
that child will not be deleted. Any files and stores associated with the entries 
are deleted.

The returned CMsvOperation object completes when deletion is complete.

@param aSelection List of ID of the entries to be deleted 
@param aStatus The request status to be completed when the operation has finished 

@leave KErrNotFound A specified entry was not a child of the context 
@leave KErrNotSupported If deleting entries from non-current drive
@return The operation object controlling the deletion command */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Asynchronous DeleteL with selection of %d entries"), aSelection.Count()); 
#endif

	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	return DoDeleteL(aSelection, aStatus);
	}



CMsvOperation* CMsvEntry::DoDeleteL(const CMsvEntrySelection& aSelection, TRequestStatus& aStatus)
//
//
//
	{
	__ASSERT_DEBUG(aSelection.Count(), PanicServer(EMsvEmptySelection));
	
	if (!AreChildren(aSelection))
		User::Leave(KErrNotFound);

	CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);
	CleanupStack::PushL(operation);
	if (iEntryPtr->iType==KUidMsvRootEntry)
		{
		// we must be deleting services - so it is a local operation
		operation->iMtm = KUidMsvLocalServiceMtm;
		operation->iService = KMsvLocalServiceIndexEntryId;
		}
	else
		User::LeaveIfError(iMsvSession.Session().OperationMtmL(aSelection.At(0), operation->iMtm, operation->iService));

#if defined(_DEBUG)
	// check other entries in selection are consistent and are not read only
	TInt dCount = aSelection.Count();
	while (dCount--)
		{
		if (iEntryPtr->iType!=KUidMsvRootEntry)
			{
				TMsvId service;
				TUid mtm;
				TInt error = iMsvSession.Session().OperationMtmL(aSelection.At(dCount), mtm, service);
				__ASSERT_DEBUG(error==KErrNone || error==KErrNotFound, PanicServer(EMsvNonConsistentDeleteSelection));
				__ASSERT_DEBUG(mtm==operation->iMtm, PanicServer(EMsvNonConsistentDeleteSelection));
				__ASSERT_DEBUG(service==operation->iService, PanicServer(EMsvNonConsistentDeleteSelection));
			}
		TMsvEntry dEntry;
		TMsvId dService;
		if (iMsvSession.Session().GetEntry(aSelection.At(dCount), dService, dEntry)==KErrNone)
			{
			__ASSERT_DEBUG(dService==iOwningService || (iEntryPtr->iType==KUidMsvServiceEntry && dService==iEntryPtr->Id()) || (iEntryPtr->iType==KUidMsvRootEntry && dService==aSelection.At(dCount)), PanicServer(EMsvDeletingEntryDifferentOwningService));
			}
		}
#endif
	
	iMsvSession.Session().DeleteEntriesL(aSelection, operation->Id(), operation->iStatus);
	operation->Start();
	CleanupStack::Pop(); // operation
	return operation;
	}

EXPORT_C void CMsvEntry::DeleteL(TMsvId aId)
/** Deletes a child entry of the context synchronously. 

The delete works recursively through all the descendants. If a child or any descendant is locked by another 
client or any store or file is open, then that child will not be deleted. Any files and stores associated 
with the entry are deleted.

This function can only be used on local entries.

@param aId ID of entry to be deleted
@leave KErrNotFound The specified entry was not a child of the context
@leave KErrNotSupported If deleting entries from non-current drive
*/
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Synchronous DeleteL, entry %x"), aId); 
#endif
	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService)); // Root as well?
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	
	User::LeaveIfError(CMsvEntry::DeleteOneL(aId));
	}

EXPORT_C void CMsvEntry::DeleteL(const CMsvEntrySelection& aSelection, TMsvLocalOperationProgress& aProgress)
/** Deletes child entries of the context synchronously. 

The delete works recursively through all the descendants. If a child or any 
descendant is locked by another client or any store or file is open, then 
that child will not be deleted. Any files and stores associated with the entries 
are deleted.

@param aSelection List of ID of the entries to be deleted 
@param aProgress Progress information for the delete operation
@leave KErrNotFound A specified entry was not a child of the context 
@leave KErrNotSupported If deleting entries from non-current drive */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Synchronous DeleteL with selection of %d entries"), aSelection.Count()); 
#endif

	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService)); // Root as well?
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	__ASSERT_DEBUG(aSelection.Count(), PanicServer(EMsvEmptySelection));

	if (!AreChildren(aSelection))
		User::Leave(KErrNotFound);

	aProgress.iTotalNumberOfEntries=aSelection.Count();
	aProgress.iNumberCompleted=0;
	aProgress.iNumberRemaining=aProgress.iTotalNumberOfEntries;
	aProgress.iError=KErrNone;

	TInt count=aProgress.iTotalNumberOfEntries;
	while(count--)
		{
		aProgress.iId=aSelection.At(count);
		TInt err=DeleteOneL(aProgress.iId);
		aProgress.iNumberRemaining--;
		if(err==KErrNone)
			aProgress.iNumberCompleted++;
		else
			{
			aProgress.iError=err;
			aProgress.iNumberFailed++;
			}
		}
	}


TInt CMsvEntry::DeleteOneL(TMsvId aMsvId)
	{
	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aMsvId);
	TInt opid = iMsvSession.OperationId();
	iMsvSession.Session().DeleteEntriesL(*selection, opid);

	TMsvLocalOperationProgress progress;
	TPckg<TMsvLocalOperationProgress> progressPack(progress);
    User::LeaveIfError(iMsvSession.Session().OperationCompletion(opid, progressPack));
	
	if(progress.iError==KErrNone)
		{
		TMsvId id = selection->At(0);
		TInt ii = iSortedChildren->Count();
		while (ii--)
			{
			if (iSortedChildren->At(ii)->Id() == id)
				{
				iSortedChildren->Delete(ii);
				break;
				}
			}

		ii = iEntries->Count();
		while (ii--)
			{
			if (iEntries->At(ii)->Entry().Id() == id)
				{
				delete iEntries->At(ii);
				iEntries->Delete(ii);
				break;
				}
			}
		// Reset the owner flag
		if (Count() == 0)
			{
			TMsvEntry* ptr = CONST_CAST(TMsvEntry*, iEntryPtr);
			ptr->SetOwner(EFalse);
			}		
		}
	CleanupStack::PopAndDestroy(selection);
	return(progress.iError);
	}




EXPORT_C CMsvEntrySelection* CMsvEntry::ChildrenL() const
//
// Gets a selection containing the children of the context
//
/** Gets a selection containing the IDs of all the context children. If the entry 
has no children, the selection is empty.

The calling function is responsible for the deletion of the returned CMsvEntrySelection. 

@leave KErrNoMemory Not enough memory to create the selection 
@return A selection containing the ID of all children of the context */
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	TInt totalCount=iSortedChildren->Count();
	for (TInt count=0; count<totalCount; count++)
		{
		selection->AppendL(iSortedChildren->At(count)->Id());
		}
	CleanupStack::Pop(); // selection
	return selection;
	}

EXPORT_C CMsvEntrySelection* CMsvEntry::ChildrenWithServiceL(TMsvId aServiceId) const
//
// Gets a selection containing the children of the context which use the service
//
/** Gets a selection containing the IDs of all the context children filtered by message service.
i.e. the index entry's iServiceId field equals aId.

If the entry has no such children, the selection is empty.

The calling function is responsible for the deletion of the returned CMsvEntrySelection.
@return	List of IDs of all children of the context meeting the criterion		
@param aServiceId Service by which to filter
@leave KErrNoMemory Not enough memory to create the selection 
*/
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	TInt totalCount=iSortedChildren->Count();
	for (TInt count=0; count<totalCount; count++)
		{
		if (iSortedChildren->At(count)->iServiceId==aServiceId)
			{
			selection->AppendL(iSortedChildren->At(count)->Id());
			}
		}
	CleanupStack::Pop(); // selection
	return selection;
	}

EXPORT_C CMsvEntrySelection* CMsvEntry::ChildrenWithMtmL(TUid aMtm) const
//
// Gets a selection containing the children of the context which use the same MTM
//
/** Gets a selection containing the IDs of all the context children filtered by 
MTM type. i.e. the index entry's iMtm field equals aMtm.

If the entry has no such children, the selection is empty.

The calling function is responsible for the deletion of the returned CMsvEntrySelection. 

@param aMtm MTM type by which to filter 
@leave KErrNoMemory Not enough memory to create the selection 
@return A selection containing the ID of all children of the context meeting 
the criterion */
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	TInt totalCount=iSortedChildren->Count();
	for (TInt count=0; count<totalCount; count++)
		{
		if (iSortedChildren->At(count)->iMtm==aMtm)
			{
			selection->AppendL(iSortedChildren->At(count)->Id());
			}
		}
	CleanupStack::Pop(); // selection
	return selection;
	}

EXPORT_C CMsvEntrySelection* CMsvEntry::ChildrenWithTypeL(TUid aType) const
//
// Gets a selection containing the children of the context which are the same type
//
/** Gets a selection containing the IDs of all the context children filtered by 
entry type. i.e. is the entry a folder, a message, etc.

If the entry has no such children, the selection is empty.

The calling function is responsible for the deletion of the returned CMsvEntrySelection. 


@param aType Entry type by which to filter. 
@leave KErrNoMemory Not enough memory to create the selection 
@return A selection containing the ID of all children of the context meeting 
the criterion */
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	TInt totalCount=iSortedChildren->Count();
	for (TInt count=0; count<totalCount; count++)
		{
		if (iSortedChildren->At(count)->iType==aType)
			{
			selection->AppendL(iSortedChildren->At(count)->Id());
			}
		}
	CleanupStack::Pop(); // selection
	return selection;
	}


#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)
/**
 * ChildrenOfAvailableDrivesL()
 *
 * @param None.
 * @return CMsvEntrySelection List of child ids from all available drives.
 * @leave KErrArgument If the function is used for a TMsvId other than that 
 * of standard folders, i.e. Inbox, Outbox, Drafts, Sent or Deleted.
 * @leave KErrNoMemory Not enough memory to create the selection.
 * 
 * Gets a selection containing the child Id's from all drives currently present
 * in the server preferred drive list.
 * The function must be used only if the context is set to one of the standard folders,
 * i.e. Inbox, Outbox, Drafts, Sent or Deleted.
 * 
 * The calling function is responsible for the deletion of the returned CMsvEntrySelection.
 *
 @publishedAll
 @released
 */ 
EXPORT_C CMsvEntrySelection* CMsvEntry::ChildrenOfAvailableDrivesL() const
    {
    __ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

    if(!iChildrenOfAvailableDrives)
        {
		User::Leave(KErrArgument);		
		}

    CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);

    TInt totalCount = iSortedChildren->Count();
	for (TInt count=0; count<totalCount; count++)
		{
		selection->AppendL(iSortedChildren->At(count)->Id());
		}
	CleanupStack::Pop(); // selection
	return selection;
	}
#endif			// #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	

EXPORT_C const TMsvEntry& CMsvEntry::operator[](TInt aIndex) const
//
// Returns the data for a child, zero index with the current sort order
//
/** Gets the index entry of the child at the position specified by the array index. 
The child entries of the context can be considered as a zero-based array, 
with entries sorted according to the current sort order. 

Note:

The function panics with E32USER-CBase 21 if aIndex was out of range.

@param aIndex Array index 
@return Index entry for the specified child. Valid for in-range values of aIndex. */
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	return *iSortedChildren->At(aIndex);
	}


EXPORT_C CMsvEntry* CMsvEntry::ChildEntryL(TMsvId aId) const
//
// Returns a new entry with the child as the context
//
/** Gets a new CMsvEntry object with its context set to the child entry ID. aMsvId 
must specify a child of the current context.

The CMsvEntry object must be deleted by the client application when it is 
no longer required. 

@param aId ID of a child entry 
@leave KErrNotFound aMsvId does not specify a child of the context 
@return CMsvEntry object with its context set to child entry */
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	if (!IsAChild(aId))
		User::Leave(KErrNotFound);
	return CMsvEntry::NewL(iMsvSession, aId, iOrdering);
	}


EXPORT_C const TMsvEntry& CMsvEntry::ChildDataL(TMsvId aId) const
//
// Returns the data for a child with the aId
//
/** Gets the index entry of context's child with the specified ID.

@param aId ID of the child 
@leave KErrNotFound No child exists with that ID 
@return Index entry for the specified child. Valid for in-range values of aIndex. */
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

	TInt count=iSortedChildren->Count();
	while (count--)
		{
		if (iSortedChildren->At(count)->Id()==aId)
			break;
		}
	User::LeaveIfError(count); // will be -1 (KErrNotFound)
	return *iSortedChildren->At(count);
	}


EXPORT_C CMsvStore* CMsvEntry::ReadStoreL()
//
// Return store for the current context which is opened for read only
//
/** Obtains the message store for the current context with read-only access. 

Multiple clients can read from a store simultaneously. If another client is already 
writing to the store, the function leaves with KErrAccessDenied. 

The returned CMsvStore must be deleted when it is no longer required. 

@leave KErrNoMemory Not enough memory to open store 
@leave KErrAccessDenied Another client is currently writing to the store 
@leave KErrNotFound There is no store associated with this entry 
@return Context's message store open for read-only access */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("ReadStoreL for entry %x"), iEntryPtr->Id()); 
#endif

	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreAlreadyOpen));
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	User::LeaveIfError(iMsvSession.Session().ReadStore(iEntryPtr->Id()));

	// open the store
	TInt err =0;
#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)
		TRAP(err, iStore = CMsvStore::OpenForReadL(*this, iMsvSession.FileSession(), iMsvSession.StoreManager(), iEntryPtr->Id(), this->Entry().iMtm));	
#else
		TRAP(err, iStore = CMsvStore::OpenForReadL(*this, iMsvSession.FileSession(), iMsvSession.StoreManager(), iEntryPtr->Id()));			
#endif
	if (err != KErrNone)
		{
		iMsvSession.Session().DecStoreReaderCount(iEntryPtr->Id()); // error ignored
		User::Leave(err);
		}
	return iStore;
	}


EXPORT_C CMsvStore* CMsvEntry::EditStoreL()
//
// Return store for the current context which can be writen to
//
/** Gets the message store for the current context with read-write access. 

Only one client can edit a message store at one time. If another client is 
already writing to the store, KErrAccessDenied is returned. Other clients 
can be reading the store. 

If the message store does not exist when EditStore() is called, a new message 
store is created. 

The returned CMsvStore must be deleted when it is no longer required. 

@leave KErrAccessDenied Store is locked by another process or the entry is 
read only 
@leave KErrNoMemory Not enough memory to open the store 
@return Context's message store open for read-write access */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("EditStoreL for entry %x"), iEntryPtr->Id()); 
#endif

	__ASSERT_ALWAYS(iStore==NULL, PanicServer(EMsvStoreAlreadyOpen));
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	
	if (iEntryPtr->ReadOnly())
		User::Leave(KErrAccessDenied);

	User::LeaveIfError(iMsvSession.Session().LockStore(iEntryPtr->Id()));

	// open the store
	TInt error = 0;
#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)	
		TRAP(error,  iStore = CMsvStore::OpenForWriteL(*this, iMsvSession.FileSession(), iMsvSession.StoreManager(), iEntryPtr->Id(), this->Entry().iMtm));
#else
		TRAP(error,  iStore = CMsvStore::OpenForWriteL(*this, iMsvSession.FileSession(), iMsvSession.StoreManager(), iEntryPtr->Id()));
#endif
	if (error)
		{
		iMsvSession.Session().ReleaseStore(iEntryPtr->Id()); // error ignored
		User::Leave(error);		
		}

	return iStore;
	}



void CMsvEntry::HandleStoreEvent(MMsvStoreObserver::TMsvStoreEvent aEvent, TMsvId /*aId*/)
//
//
//
	{
	switch (aEvent)
		{
		case EMsvEditStoreClosed:
			iMsvSession.Session().ReleaseStore(iEntryPtr->Id()); // error ignored
			iStore=NULL;
			break;
		case EMsvReadStoreClosed:
			iMsvSession.Session().DecStoreReaderCount(iEntryPtr->Id()); // error ignored
			iStore=NULL;
			break;
		default:
			__ASSERT_DEBUG(EFalse, PanicServer(EMsvUnknownStoreEvent3));
		}

	}


EXPORT_C CMsvOperation* CMsvEntry::MoveL(TMsvId aMsvId, TMsvId aTargetId, TRequestStatus& aStatus)
//
// Move a single child to another parent
//
/** Moves, asynchronously, a child of the context to become an entry owned by the target entry. 

All descendants will be moved as well. Any files and stores associated with 
the entry are also moved.

The returned CMsvOperation object completes when moving is complete.

@param aMsvId The ID of the entry to be moved 
@param aTargetId The ID of the entry to own the moved entries 
@param aStatus The request status to be completed when the operation has finished 

@leave KErrNoMemory The operation could not be created or passed to the server 
@leave KErrNotFound An entry was not a child of the context 
@return The operation object controlling the move command. */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Asynchronous MoveL %x to %x"), aMsvId, aTargetId); 
#endif

	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aMsvId);
	CMsvOperation* operation = MoveL(*selection, aTargetId, aStatus);
	CleanupStack::PopAndDestroy(); // selection
	return operation;
	}


TInt CMsvEntry::MoveOneL(TMsvId aMsvId, TMsvId aTargetId)
	{
	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aMsvId);
	TInt opid = iMsvSession.OperationId();
	iMsvSession.Session().MoveEntriesL(*selection, aTargetId, opid);

	TMsvLocalOperationProgress progress;
	TPckg<TMsvLocalOperationProgress> progressPack(progress);
    User::LeaveIfError(iMsvSession.Session().OperationCompletion(opid, progressPack));
	
	if(progress.iError==KErrNone)
		{
		TMsvId id = selection->At(0);
		TInt ii = iSortedChildren->Count();
		while (ii--)
			{
			if (iSortedChildren->At(ii)->Id() == id)
				{
				iSortedChildren->Delete(ii);
				break;
				}
			}

		ii = iEntries->Count();
		while (ii--)
			{
			if (iEntries->At(ii)->Entry().Id() == id)
				{
				delete iEntries->At(ii);
				iEntries->Delete(ii);
				break;
				}
			}
		// Reset the owner flag
		if (Count() == 0)
			{
			TMsvEntry* ptr = CONST_CAST(TMsvEntry*, iEntryPtr);
			ptr->SetOwner(EFalse);
			}		
		}
	CleanupStack::PopAndDestroy(selection);
	return(progress.iError);
	}

/** Moves, synchronously, a child of the context to become an entry owned by the target entry. 

All descendants will be moved as well. Any files and stores associated with 
the entry are also moved.

@param aMsvId The ID of the entry to be moved 
@param aTargetId The ID of the entry to own the moved entries 

@leave KErrNoMemory 
@leave KErrNotFound An entry was not a child of the context 
*/
EXPORT_C void CMsvEntry::MoveL(TMsvId aMsvId, TMsvId aTargetId)
//
// Move a single child to another parent
//
	{
	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService)); // Root as well?
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	__ASSERT_DEBUG(aTargetId!=iEntryPtr->Id(), PanicServer(EMsvMovingEntryToSameParent));

#ifndef _NO_SESSION_LOGGING_
	Log(_L("Synchronous MoveL %x to %x"), aMsvId, aTargetId); 
#endif
	User::LeaveIfError(MoveOneL(aMsvId,aTargetId));
	}


/** Moves, synchronously, children of the context to become entries owned by the target entry. 

All descendants will be moved as well. Any files and stores associated with 
the entries are also moved.

@param aSelection List of IDs of the entries to be moved 
@param aTargetId The ID of the entry to own the moved entires 
@param aProgress On return, records the outcome of the move 

@leave KErrNoMemory 
@leave KErrNotFound An entry was not a child of the context 
*/
EXPORT_C void CMsvEntry::MoveL(const CMsvEntrySelection& aSelection, TMsvId aTargetId, TMsvLocalOperationProgress& aProgress)
//
// Move a selection of children to another parent
//
	{
	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService)); // Root as well?
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	__ASSERT_DEBUG(aTargetId!=iEntryPtr->Id(), PanicServer(EMsvMovingEntryToSameParent));
	__ASSERT_DEBUG(aSelection.Count(), PanicServer(EMsvEmptySelection));


#ifndef _NO_SESSION_LOGGING_
	Log(_L("Synchronous MoveL with selection of %d entries to %x"), aSelection.Count(),aTargetId); 
#endif

	aProgress.iTotalNumberOfEntries=aSelection.Count();
	aProgress.iNumberCompleted=0;
	aProgress.iNumberRemaining=aProgress.iTotalNumberOfEntries;
	aProgress.iError=KErrNone;

	TInt count=aProgress.iTotalNumberOfEntries;
	while(count--)
		{
		aProgress.iId=aSelection.At(count);
		TInt err=MoveOneL(aProgress.iId,aTargetId);
		aProgress.iNumberRemaining--;
		if(err==KErrNone)
			aProgress.iNumberCompleted++;
		else
			{
			aProgress.iError=err;
			aProgress.iNumberFailed++;
			}
		}
	}






EXPORT_C CMsvOperation* CMsvEntry::MoveL(const CMsvEntrySelection& aSelection, TMsvId aTargetId, TRequestStatus& aStatus)
//
// Move a selection of children to another parent
//
/** Moves, asynchronously, children of the context to become entries owned by the target entry. 

All descendants will be moved as well. Any files and stores associated with 
the entries are also moved.

The returned CMsvOperation object completes when moving is complete.

@param aSelection List of IDs of the entries to be moved 
@param aTargetId The ID of the entry to own the moved entires 
@param aStatus The request status to be completed when the operation has finished 

@leave KErrNoMemory The operation could not be created or passed to the server 
@leave KErrNotFound An entry was not a child of the context 
@return The operation object controlling the move command. */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Asynchronous MoveL of selection of %d entries to %x"), aSelection.Count(), aTargetId); 
#endif

	__ASSERT_DEBUG(aTargetId!=iEntryPtr->Id(), PanicServer(EMsvMovingEntryToSameParent));
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	if (!AreChildren(aSelection))
		User::Leave(KErrNotFound);
	CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);
	CleanupStack::PushL(operation);
	User::LeaveIfError(iMsvSession.Session().OperationMtmL(aSelection.At(0), aTargetId, operation->iMtm, operation->iService));

#if defined(_DEBUG)
	// check other entries in selection are consistent and are not read only
	TInt dCount = aSelection.Count();
	while (dCount--)
		{
		TMsvId service;
		TUid mtm;
		TInt error = iMsvSession.Session().OperationMtmL(aSelection.At(dCount), aTargetId, mtm, service);
		__ASSERT_DEBUG(error==KErrNone || error==KErrNotFound, PanicServer(EMsvMulitpleMtmsForMoveCommand));
		__ASSERT_DEBUG(mtm==operation->iMtm, PanicServer(EMsvMulitpleMtmsForMoveCommand));
		__ASSERT_DEBUG(service==operation->iService, PanicServer(EMsvMulitpleMtmsForMoveCommand));
		TMsvEntry dEntry;
		TMsvId dService;
		if (iMsvSession.Session().GetEntry(aSelection.At(dCount), dService, dEntry)==KErrNone)
			__ASSERT_DEBUG(dService==iOwningService || (iEntryPtr->iType==KUidMsvServiceEntry && dService==iEntryPtr->Id()) || (iEntryPtr->iType==KUidMsvRootEntry && service==aSelection.At(dCount)), PanicServer(EMsvMovingEntryDifferentOwningService));
		}
#endif

	iMsvSession.Session().MoveEntriesL(aSelection, aTargetId, operation->Id(), operation->iStatus);
	operation->Start();
	CleanupStack::Pop(); // operation
	return operation;
	}


EXPORT_C CMsvOperation* CMsvEntry::CopyL(const CMsvEntrySelection& aSelection, TMsvId aTargetId, TRequestStatus& aStatus)
//
// Copy a selection ocf children to another parent
//
/** Creates, asynchronously. copies of children of the context as new entries owned by the specified 
target ID.

All descendants will be copied as well. Any files and stores associated with 
the entries are also copied.

The returned CMsvOperation object completes when copying is complete.

@param aSelection List of IDs of the entries to be copied 
@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 KErrNoMemory The operation could not be created or passed to the server 
@leave KErrNotFound An entry was not a child of the context 
@return The operation object controlling the copy command. */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Asynchronous CopyL of selection of %d entries to %x"), aSelection.Count(), aTargetId); 
#endif

	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	if (!AreChildren(aSelection))
		User::Leave(KErrNotFound);
	CMsvEntryOperation* operation = CMsvEntryOperation::NewL(iMsvSession, aStatus);
	CleanupStack::PushL(operation);
	User::LeaveIfError(iMsvSession.Session().OperationMtmL(aSelection.At(0), aTargetId, operation->iMtm, operation->iService)); 

#if defined(_DEBUG)
	// check other entries in selection are consistent 
	TInt dCount = aSelection.Count();
	while (dCount--)
		{
		TMsvId service;
		TUid mtm;
		TInt error = iMsvSession.Session().OperationMtmL(aSelection.At(dCount), aTargetId, mtm, service);
		__ASSERT_DEBUG(error==KErrNone || error==KErrNotFound, PanicServer(EMsvMulitpleMtmsForCopyCommand));
		__ASSERT_DEBUG(mtm==operation->iMtm, PanicServer(EMsvMulitpleMtmsForCopyCommand));
		__ASSERT_DEBUG(service==operation->iService, PanicServer(EMsvMulitpleMtmsForCopyCommand));
		TMsvEntry dEntry;
		TMsvId dService;
		if (iMsvSession.Session().GetEntry(aSelection.At(dCount), dService, dEntry)==KErrNone)
			__ASSERT_DEBUG(dService==iOwningService || (iEntryPtr->iType==KUidMsvServiceEntry && dService==iEntryPtr->Id()) || (iEntryPtr->iType==KUidMsvRootEntry && service==aSelection.At(dCount)), PanicServer(EMsvCopyingEntryDifferentOwningService));
		}
#endif

	iMsvSession.Session().CopyEntriesL(aSelection, aTargetId, operation->Id(), operation->iStatus);
	operation->Start();
	CleanupStack::Pop(); // operation
	return operation;
	}

EXPORT_C CMsvOperation* CMsvEntry::CopyL(TMsvId aMsvId, TMsvId aTargetId, TRequestStatus& aStatus)
//
// Copy a single entry to another parent
//
/** Creates, asynchronously, a copy of a child of the context as a new entry owned by the specified 
target ID.

All descendants will be copied as well. Any files and stores associated with 
the entry are also copied.

The returned CMsvOperation object completes when copying is complete.

@param aMsvId The ID of the entry to be copied 
@param aTargetId The ID of the entry to own the copy 
@param aStatus The request status to be completed when the operation has finished 

@leave KErrNoMemory The operation could not be created or passed to the server 
@leave KErrNotFound An entry was not a child of the context 
@return The operation object controlling the copy command. */
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Asynchronous CopyL of entry %x to %x"), aMsvId, aTargetId); 
#endif

	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aMsvId);
	CMsvOperation* operation = CopyL(*selection, aTargetId, aStatus);
	CleanupStack::PopAndDestroy(); // selection
	return operation;
	}


TInt CMsvEntry::CopyOneL(TMsvId aMsvId, TMsvId aTargetId)
	{

	CMsvEntryArray* newSortedChildren = NULL;
	CMsvClientEntry *toadd=NULL;

	
	if(aTargetId==iEntryPtr->Id())
		{
		const TMsvEntry &entry=ChildDataL(aMsvId);
		if (entry.Visible() || iOrdering.ShowInvisibleEntries())
			{
			// Create what may be the new child entry if nothing goes wrong
			toadd = CMsvClientEntry::NewLC(entry, EMsvClientChild);

			// Reserve space for the new entry for later
			iEntries->SetReserveL(iEntries->Count() + 1);

			newSortedChildren = CMsvEntryArray::NewLC(*iMtmList);

			// add the children to the sorted pointer list - current context is the first entry
			TInt totalCount=iEntries->Count();
			for (TInt count=1; count<totalCount; count++)
				newSortedChildren->AppendL(&iEntries->At(count)->Entry());

			// We've created a new sorted child list now so we won't leave later
			newSortedChildren->AppendL(&toadd->Entry());
			newSortedChildren->SortL(iOrdering);
			}
		}

	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aMsvId);
	TInt opid = iMsvSession.OperationId();
	iMsvSession.Session().CopyEntriesL(*selection, aTargetId, opid);

	TMsvLocalOperationProgress progress;
	TPckg<TMsvLocalOperationProgress> progressPack(progress);
    User::LeaveIfError(iMsvSession.Session().OperationCompletion(opid, progressPack));

	CleanupStack::PopAndDestroy(selection);

	// can't leave after this point
	if(newSortedChildren!=NULL) CleanupStack::Pop(newSortedChildren);
	if(toadd!=NULL) CleanupStack::Pop(toadd);
	if(newSortedChildren!=NULL && progress.iError==KErrNone)
		{
		delete iSortedChildren;
		iSortedChildren=newSortedChildren;
		newSortedChildren=NULL;
		toadd->SetId(progress.iId);
		// Will not leave because we've reserved space earlier
		iEntries->AppendL(toadd);
		toadd=NULL;
		}
	delete newSortedChildren;
	delete toadd;
	return(progress.iError);
	}

EXPORT_C void CMsvEntry::CopyL(TMsvId aMsvId, TMsvId aTargetId)
//
// Copy a single child to another parent (or duplicate)
//
/** Creates, synchronously, a copy of a child of the context as a new entry owned by the specified target ID.

@param aMsvId The ID of the entry to be copied
@param aTargetId The ID of the entry to own the copy
*/
	{	
	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService)); // Root as well?
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Synchronous CopyL %x to %x"), aMsvId, aTargetId); 
#endif
	User::LeaveIfError(CopyOneL(aMsvId,aTargetId));
	}


/** Creates, synchronously. copies of children of the context as new entries owned by the specified 
target ID.

All descendants will be copied as well. Any files and stores associated with 
the entries are also copied.

@param aSelection List of IDs of the entries to be copied 
@param aTargetId The ID of the entry to own the copies 
@param aProgress On return, records the outcome of the copy 

@leave KErrNoMemory 
@leave KErrNotFound An entry was not a child of the context 
*/
EXPORT_C void CMsvEntry::CopyL(const CMsvEntrySelection& aSelection, TMsvId aTargetId, TMsvLocalOperationProgress& aProgress)
//
// Copy a selection to another parent (or duplicate)
//
	{
	__ASSERT_ALWAYS(iOwningService == KMsvLocalServiceIndexEntryId || iOwningService == KMsvRootIndexEntryId, PanicServer(EMsvNotLocalService)); // Root as well?
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	__ASSERT_DEBUG(aSelection.Count(), PanicServer(EMsvEmptySelection));

#ifndef _NO_SESSION_LOGGING_
	Log(_L("Synchronous CopyL with selection of %d entries to %x"), aSelection.Count(),aTargetId); 
#endif


	aProgress.iTotalNumberOfEntries=aSelection.Count();
	aProgress.iNumberCompleted=0;
	aProgress.iNumberRemaining=aProgress.iTotalNumberOfEntries;
	aProgress.iError=KErrNone;

	TInt count=aProgress.iTotalNumberOfEntries;
	while(count--)
		{
		aProgress.iId=aSelection.At(count);
		TInt err=CopyOneL(aProgress.iId,aTargetId);
		aProgress.iNumberRemaining--;
		if(err==KErrNone)
			aProgress.iNumberCompleted++;
		else
			{
			aProgress.iError=err;
			aProgress.iNumberFailed++;
			}
		}
	}





EXPORT_C void CMsvEntry::AddObserverL(MMsvEntryObserver& aObserver)
//
// Adds an observer to this entry
// If the function leaves, the observer was not appended
// 
/** Registers an observer for the object. 

CMsvEntry objects can call back observer objects that implement the MMsvEntryObserver 
interface when certain events occur. Any number of observers can be registered.

Observers are called primarily when the context changes state or contents. 
For details, see MMsvEntryObserver::TMsvEntryEvent.

@param aObserver The observer to be registered for events 
@leave KErrNoMemory Not enough memory to register the observer */
	{
	if (iObservers==NULL)
		iObservers=new(ELeave) CArrayPtrFlat<MMsvEntryObserver> (KMsvEntryObserverArrayGranuality);
	iObservers->AppendL(&aObserver);

#ifndef _NO_SESSION_LOGGING_
	Log(_L("Observer %d added"), iObservers->Count()); 
#endif
	}


EXPORT_C void CMsvEntry::RemoveObserver(MMsvEntryObserver& aObserver)
//
// Removes an observer of the entry
//
/** Unregisters an observer previously registered with AddObserverL(). 

@param aObserver A reference to an observer to be unregistered for events */
	{
	__ASSERT_DEBUG(iObservers, PanicServer(EMsvEntryUnknownObserver));
	if (iObservers)
		{
		TInt count=iObservers->Count();
		while (count--)
			{
			if (iObservers->At(count)==&aObserver)
				{
#ifndef _NO_SESSION_LOGGING_
				Log(_L("Observer %d removed"), count + 1); 
#endif
				iObservers->Delete(count);
				if (iObservers->Count()==0)
					{
					delete iObservers;
					iObservers=NULL;
					}
				return;
				}
			}
		__ASSERT_DEBUG(count>=0, PanicServer(EMsvEntryUnknownObserver));
		}
	}


void CMsvEntry::NotifyAllObserversL(MMsvEntryObserver::TMsvEntryEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3)
//
// Notifies all observers of the event affecting the context
//
	{
	if (iObservers==NULL)
		return;
	TInt count=iObservers->Count();
	while (count--)
		iObservers->At(count)->HandleEntryEventL(aEvent,aArg1,aArg2,aArg3);	
	}


void CMsvEntry::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* aArg2, TAny* aArg3)
//
// Is informed of all the session events
// This are filtered to find the events relating to the context
//
	{
	// Check the notification sequence and ignore if neccessary
	if (iNotifySequence >= iMsvSession.iNotifySequence)
		{
#ifndef _NO_SESSION_LOGGING_
		Log(_L("Ignoring notification, %d >= %d"), iNotifySequence, iMsvSession.iNotifySequence); 
#endif
		return;
		}

	switch (aEvent)
		{
		case EMsvEntriesChanged:
			{
			CMsvEntrySelection* selection = (CMsvEntrySelection*) aArg1;
			if (iEntryPtr->Id() == selection->At(0))
				ContextChangedL(MMsvEntryObserver::EMsvEntryChanged);
			else if (iEntryPtr->Id()==*(TMsvId*) aArg2)
				ChildrenChangedL(*selection);
			break;
			}
		case EMsvEntriesCreated:
			if (*(TMsvId*) aArg2==iEntryPtr->Id())
				NewChildrenL(*(CMsvEntrySelection*) aArg1);
			else
				CheckNewGrandchildrenL(*(TMsvId*) aArg2);
			break;
		case EMsvEntriesDeleted:
			{
			CMsvEntrySelection* selection = (CMsvEntrySelection*) aArg1;
			if (*(TMsvId*) aArg2==iEntryPtr->Id())
				DeletedChildrenL(*selection);
			else
				{
				// check if we have been deleted
				TInt index=selection->Find(iEntryPtr->Id());
				if (index!=KErrNotFound)
					{
					iState = EInvalidDeletedContext;
					NotifyAllObserversL(MMsvEntryObserver::EMsvEntryDeleted, NULL, NULL, NULL);
					}
				else
					CheckDeletedGrandchildrenL(*(TMsvId*) aArg2);
				}
			break;
			}
		case EMsvEntriesMoved:
			if (*(TMsvId*) aArg3==iEntryPtr->Parent())
				CheckIfContextMovedL(*(CMsvEntrySelection*) aArg1);
			if (*(TMsvId*) aArg2==iEntryPtr->Id())
				NewChildrenL(*(CMsvEntrySelection*) aArg1);
			else if (*(TMsvId*) aArg3==iEntryPtr->Id())
				DeletedChildrenL(*(CMsvEntrySelection*) aArg1);
			else
				{
				CheckNewGrandchildrenL(*(TMsvId*) aArg2);
				CheckDeletedGrandchildrenL(*(TMsvId*) aArg3);
				}
			break;
		case EMsvMediaChanged:
			{
			TRAPD(error, HandleMediaChangeL());			
			if (error)
				{
				// An error occurred or this is a non standard entry
				// in which case the media has changed so this entry is not accessible
				// Just mark the entry as invalid - there is nothing else we can do!
				iState = EInvalidOldContext;
				NotifyAllObserversL(MMsvEntryObserver::EMsvContextInvalid, (TAny*)&error, NULL, NULL);
				}
			break;
			}
#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)
		case EMsvRefreshMessageView:
			{
			// A drive/disk has been added/removed.
			if(iEntryPtr->StandardFolder())
				{
				SetEntryNoCheckL(iEntryPtr->Id(), iChildrenOfAvailableDrives);
				}
			break;
			}
#endif
		default:
			break;
		}
	}

void CMsvEntry::HandleMediaChangeL()
	{
	// If this is not a standard entry there is nothing we can do
	if (!iEntryPtr->StandardFolder())
		User::Leave(KMsvMediaChanged);

	// This is a standard folder so it will exist on all media
	// Refresh the entry and child list - if this fails mark the entry as invalid
	// Otherwise the context will be told that everything has changed
	CMsvEntrySelection* oldChildren = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(oldChildren);

	// Get list of old children
	TInt count = iSortedChildren->Count();
	while(count--)
		oldChildren->AppendL(iSortedChildren->At(count)->Id());

	// Refresh the context
	iState = EInvalidOldContext;

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)
	if(iChildrenOfAvailableDrives)
		{
		SetStandardFolderEntryL(iEntryPtr->Id());
		}
	else
#endif
		{
		SetEntryL(iEntryPtr->Id());
		}
	CMsvEntrySelection* newChildren = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(newChildren);

	// Get list of new children
	count = iSortedChildren->Count();
	while(count--)
		newChildren->AppendL(iSortedChildren->At(count)->Id());

	// Tell the context about the children that have effectively been deleted and created
	if (oldChildren->Count())
		NotifyAllObserversL(MMsvEntryObserver::EMsvDeletedChildren, (TAny*)oldChildren, NULL, NULL);
	if (newChildren->Count())
		NotifyAllObserversL(MMsvEntryObserver::EMsvNewChildren, (TAny*)newChildren, NULL, NULL);

	// Tell the context that it might have changed
	NotifyAllObserversL(MMsvEntryObserver::EMsvEntryChanged, NULL, NULL, NULL);

	CleanupStack::PopAndDestroy(2); // newChildren, oldChildren
	}

void CMsvEntry::CheckIfContextMovedL(const CMsvEntrySelection& aSelection)
//
// Some of the contexts parents children have moved, have to check if the context was one of them
//
	{
	TInt index=aSelection.Find(iEntryPtr->Id());
	if (index!=KErrNotFound)
		ContextChangedL(MMsvEntryObserver::EMsvEntryMoved);
	}


void CMsvEntry::ContextChangedL(MMsvEntryObserver::TMsvEntryEvent aEvent)
//
// The context has ben changed, spo we need to get the enw version
//
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Context changed")); 
#endif

	if (iEntries->Count()>1 && iEntries->At(1)->Type()==EMsvClientChangedContext)
		{
		// we changed the entry, so get the new conext from the entry list
		// delete the old entry context (the new one is at position 1)
		delete iEntries->At(0);
		iEntries->Delete(0);
		}
	else
		{
		// someone else changed the context, so we have to update
		CMsvClientEntry* cEntry=NULL;
		TMsvId owningService=KMsvNullIndexEntryId;
		TRAPD(error, {cEntry = DoGetEntryLC(iEntryPtr->Id(), owningService); CleanupStack::Pop();});
		if (error==KErrNone)
			{
			if(iEntries->Count() != 0)
				{
				delete iEntries->At(0);
				iEntries->At(0) = cEntry;
				}
			else
				{
				iEntries->AppendL(cEntry); 	
				}
			iOwningService = owningService;
			}
		else
			{
			iState = EInvalidOldContext;
			NotifyAllObserversL(MMsvEntryObserver::EMsvContextInvalid, (TAny*)&error, NULL, NULL);
			return;
			}
		}

	iEntries->At(0)->SetType(EMsvClientContext);
	iEntryPtr = &iEntries->At(0)->Entry();
	iState = EValid;

	// notify all observers
	NotifyAllObserversL(aEvent, NULL, NULL, NULL);
	}



void CMsvEntry::NewChildrenL(const CMsvEntrySelection& aSelection)
//
// New children have been created
//
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("New children")); 
#endif

	CMsvEntrySelection* newChildren = DoGetNewChildrenL(aSelection);
	CleanupStack::PushL(newChildren);
	if (newChildren->Count())
		{
		TMsvEntry* ptr = CONST_CAST(TMsvEntry*, iEntryPtr);
		ptr->SetOwner(ETrue);
		NotifyAllObserversL(MMsvEntryObserver::EMsvNewChildren, (TAny*)newChildren, NULL, NULL);
		}
	CleanupStack::PopAndDestroy(); // newChildren
	}


CMsvEntrySelection* CMsvEntry::DoGetNewChildrenL(const CMsvEntrySelection& aSelection)
//
// New children have been created
//
	{
	CMsvEntrySelection* newChildren = aSelection.CopyLC();
	TInt count=aSelection.Count();
	while (count--)
		{
		// check if we already have this child
		if (IsAChild(aSelection.At(count)))
			{
			newChildren->Delete(count);
			continue;
			}

		// get the new child data and add to to the list
		TMsvEntry tEntry;
		TMsvId service;
		TInt error=iMsvSession.Session().GetEntry(aSelection.At(count), service, tEntry);
		if(error!=KErrNotFound) User::LeaveIfError(error);
		
		if (error == KErrNone && (tEntry.Visible() || iOrdering.ShowInvisibleEntries()))
			{
			__ASSERT_DEBUG(service==iOwningService || (iEntryPtr->iType==KUidMsvServiceEntry && service==iEntryPtr->Id()) || (iEntryPtr->iType==KUidMsvRootEntry && service==(aSelection.At(count))), PanicServer(EMsvNewChildDifferentOwningService));

			CMsvClientEntry* cEntry = CMsvClientEntry::NewLC(tEntry, EMsvClientNull);
			cEntry->SetType(EMsvClientChild);
			iEntries->AppendL(cEntry);
			CleanupStack::Pop(); // cEntry
			// resort the children
			iSortedChildren->AppendL(&cEntry->Entry());
			}
		else
			newChildren->Delete(count);
		}
	
	if (newChildren->Count())
		iSortedChildren->SortL(iOrdering);
	CleanupStack::Pop(); // newChildren
	return newChildren;
	}


void CMsvEntry::CheckNewGrandchildrenL(TMsvId aId)
//
//
//
	{
	TInt count=iEntries->Count();
	while (count--)
		{
		if (iEntries->At(count)->Entry().Id()==aId && !iEntries->At(count)->Entry().Owner())
			{
			iEntries->At(count)->SetOwnerFlag(ETrue);
			NotifyChildChangedL(aId);
			break;
			}
		}
	}


void CMsvEntry::CheckDeletedGrandchildrenL(TMsvId aId)
//
//
//
	{
	TInt count=iEntries->Count();
	while (count--)
		{
		if (iEntries->At(count)->Entry().Id()==aId)
			{
			TMsvEntry entry;
			TMsvId service;
			TInt error = iMsvSession.Session().GetEntry(aId, service, entry);
			__ASSERT_DEBUG(error || service==iOwningService || (iEntryPtr->iType==KUidMsvServiceEntry && service==iEntryPtr->Id()) || (iEntryPtr->iType==KUidMsvRootEntry && service==aId), PanicServer(EMsvDeletedGrandChildDifferentOwningService));
			if (error)
				NotifyAllObserversL(MMsvEntryObserver::EMsvChildrenInvalid, (TAny*)&error, NULL, NULL);
			else if (!entry.Owner())
				{
				iEntries->At(count)->SetOwnerFlag(EFalse);
				NotifyChildChangedL(aId);
				}
			break;
			}
		}
	}


void CMsvEntry::NotifyChildChangedL(TMsvId aId)
//
//
//
	{
	CMsvEntrySelection* selection = DoMakeSelectionL(aId);
	CleanupStack::PushL(selection);
	NotifyAllObserversL(MMsvEntryObserver::EMsvChildrenChanged, (TAny*)selection, NULL, NULL);
	CleanupStack::PopAndDestroy(); // selection
	}


CMsvEntrySelection* CMsvEntry::DoMakeSelectionL(TMsvId aId)
//
//
//
	{
	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aId);
	CleanupStack::Pop(); // selection
	return selection;
	}


void CMsvEntry::ChildrenChangedL(const CMsvEntrySelection& aSelection)
//
// Children have been changed
//
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Children changed")); 
#endif

	CMsvEntrySelection* changedChildren = new(ELeave) CMsvEntrySelection;
	CleanupStack::PushL(changedChildren);
	CMsvEntrySelection* newChildren = new(ELeave) CMsvEntrySelection;
	CleanupStack::PushL(newChildren);
	CMsvEntrySelection* deletedChildren = new(ELeave) CMsvEntrySelection;
	CleanupStack::PushL(deletedChildren);

	TInt count=aSelection.Count();
	while (count--)
		{
		// get the changed child data
		TMsvId id = aSelection.At(count);
		TMsvEntry tEntry;
		TMsvId service;

		// find the child in the sorted list
		TInt pos=iSortedChildren->Count();
		while (pos--)
			if (iSortedChildren->At(pos)->Id()==id)
				break;

		TInt error = iMsvSession.Session().GetEntry(id, service, tEntry);
		if (error == KErrNotFound)
			{
			if (pos >= 0)
				{
				// The child has been deleted by the server
				DeleteChild(pos);
				deletedChildren->AppendL(id);
				}
			}
		else
			{
			User::LeaveIfError(error);
			__ASSERT_DEBUG(service==iOwningService || (iEntryPtr->iType==KUidMsvServiceEntry && service==iEntryPtr->Id()) || (iEntryPtr->iType==KUidMsvRootEntry && service==id), PanicServer(EMsvChangedChildHasDifferentOwningService));

			if ( pos!=KErrNotFound  )
				{
				// replace it, if showing all children or its was and still is visible
				if (iOrdering.ShowInvisibleEntries() || tEntry.Visible())
					{
					ReplaceChildL(pos, tEntry);
					changedChildren->AppendL(id);
					continue;
					}
				}

			if ( pos==KErrNotFound )
				{
				if (tEntry.Visible())
					{
					// the child has just been made visible so add it to our sorted list
					CMsvClientEntry* cEntry = CMsvClientEntry::NewLC(tEntry, EMsvClientChild);
					iEntries->AppendL(cEntry);
					CleanupStack::Pop(); // cEntry
					iSortedChildren->AppendL(&cEntry->Entry());
					newChildren->AppendL(id);		
					}				
				}
			else if (!tEntry.Visible())
				{
				DeleteChild(pos);
				deletedChildren->AppendL(id);
				}
			}
		}
	
	// resort the children
	if (changedChildren->Count() || newChildren->Count() || deletedChildren->Count())
		{
		iSortedChildren->SortL(iOrdering);
		// notify the observers
		if (changedChildren->Count())
			NotifyAllObserversL(MMsvEntryObserver::EMsvChildrenChanged, (TAny*)changedChildren, NULL, NULL);
		if (newChildren->Count())
			NotifyAllObserversL(MMsvEntryObserver::EMsvNewChildren, (TAny*)newChildren, NULL, NULL);
		if (deletedChildren->Count())
			NotifyAllObserversL(MMsvEntryObserver::EMsvDeletedChildren, (TAny*)deletedChildren, NULL, NULL);
		}

	CleanupStack::PopAndDestroy(3); // changedChildren, newChildren, deletedChildren
	}

void CMsvEntry::DeleteChild(TInt aPosition)
	{
	TMsvId id = iSortedChildren->At(aPosition)->Id();
	iSortedChildren->Delete(aPosition);
	TInt ii=iEntries->Count();
	while (ii--)
		if (iEntries->At(ii)->Entry().Id()==id)
			{
			__ASSERT_DEBUG(iEntries->At(ii)->Type()==EMsvClientChild, PanicServer(EMsvNonChildDeleted));
			delete iEntries->At(ii);
			iEntries->Delete(ii);
			break;
			}
	__ASSERT_DEBUG(ii!=KErrNotFound, PanicServer(EMsvChangedChildNotFound1));
	}

void CMsvEntry::ReplaceChildL(TInt aPosition, const TMsvEntry& aEntry)
//
//
//
	{
	CMsvClientEntry* cEntry = CMsvClientEntry::NewLC(aEntry, EMsvClientChild);
			
	TInt ii=iEntries->Count();
	while (ii--)
		{
		if (iEntries->At(ii)->Entry().Id()==aEntry.Id())
			{
			__ASSERT_DEBUG(iEntries->At(ii)->Type()==EMsvClientChild, PanicServer(EMsvNonChildDeleted));
			delete iEntries->At(ii);
			iEntries->At(ii) = cEntry;
			iSortedChildren->At(aPosition) = &cEntry->Entry();
			break;
			}
		}
	__ASSERT_DEBUG(ii!=KErrNotFound, PanicServer(EMsvChangedChildNotFound1));

	CleanupStack::Pop(); // cEntry
	}



void CMsvEntry::DeletedChildrenL(const CMsvEntrySelection& aSelection)
//
// Some of the children have been deleted
//
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("Deleted children")); 
#endif

	CMsvEntrySelection* deletedChildren = aSelection.CopyL();
	CleanupStack::PushL(deletedChildren);

	TInt count=aSelection.Count();
	while (count--)
		{
		TMsvId id = aSelection.At(count);
		TInt ii=iSortedChildren->Count();
		while (ii--)
			{
			if (iSortedChildren->At(ii)->Id()==id)
				{
				iSortedChildren->Delete(ii);
				break;
				}
			}
		if (ii==KErrNotFound)
			deletedChildren->Delete(count);
		else
			{
			ii=iEntries->Count();
			while (ii--)
				{
				if (iEntries->At(ii)->Entry().Id()==id)
					{
					__ASSERT_DEBUG(iEntries->At(ii)->Type()==EMsvClientChild, PanicServer(EMsvNonChildDeleted));
					delete iEntries->At(ii);
					iEntries->Delete(ii);
					break;
					}
				__ASSERT_DEBUG(ii!=KErrNotFound, PanicServer(EMsvDeletedChildNotInMainList));
				}
			}
		}

	// notify all observers
	if (deletedChildren->Count())
		{
		// reset the owner flag
		if (Count()==0)
			{
			TMsvEntry* ptr = CONST_CAST(TMsvEntry*, iEntryPtr);
			ptr->SetOwner(EFalse);
			}

		NotifyAllObserversL(MMsvEntryObserver::EMsvDeletedChildren, (TAny*)deletedChildren, NULL, NULL);
		}

	CleanupStack::PopAndDestroy(); // deletedChildren
	}


CMsvEntryArray* CMsvEntry::GetNewSortedListL(const TMsvSelectionOrdering& aOrdering, const CArrayFix<TUid>& aMtmList)
//
// Gets a new sorted list for new order and mtm list
// The entries should have the correct visiblity
//
	{
	CMsvEntryArray* newSortedChildren = CMsvEntryArray::NewLC(aMtmList);
	if (iSortedChildren->Count())
		{
//		newSortedChildren->InsertL(0, &iSortedChildren->At(0), iSortedChildren->Count());
//		newSortedChildren->SortL(aOrdering);
		TInt count=1;
		if (iEntries->At(count)->Type()!=EMsvClientChild)
			count++;
		TInt totalCount=iEntries->Count();
		for (; count<totalCount; count++)
			newSortedChildren->AppendL(&iEntries->At(count)->Entry());
		newSortedChildren->SortL(aOrdering);
		}
	CleanupStack::Pop(); // newSortedChildren
	return newSortedChildren;
	}


EXPORT_C void CMsvEntry::SetSortTypeL(const TMsvSelectionOrdering& aOrdering)
//
// Sets the sort type
// If this leaves the sort type has not been changed
//
/** Sets the sort order that is used when listing children, for example with ChildrenL().

If the function leaves, the sort order is unchanged.

@param aOrdering Sort order to use 
@leave KErrNoMemory Insufficient memory to resort the entries */
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

#ifndef _NO_SESSION_LOGGING_
		Log(_L("Sort order changed, sorting %x, invisible %d"), aOrdering.Sorting(), aOrdering.ShowInvisibleEntries()); 
#endif

	if (aOrdering.ShowInvisibleEntries()==iOrdering.ShowInvisibleEntries())
		{
		// just resort the current list of children
		CMsvEntryArray* newSortedChildren = GetNewSortedListL(aOrdering, *iMtmList);
		delete iSortedChildren;
		iSortedChildren = newSortedChildren;
		iOrdering = aOrdering;
		}
	else if (!aOrdering.ShowInvisibleEntries())
		{
		// resort the current list
		CMsvEntryArray* newSortedChildren = GetNewSortedListL(aOrdering, *iMtmList);
		delete iSortedChildren;
		iSortedChildren = newSortedChildren;
		iOrdering = aOrdering;
		// remove the invisible entries from sort list
		TInt count = iSortedChildren->Count();
		while (count--)
			if (!iSortedChildren->At(count)->Visible())
				iSortedChildren->Delete(count);
		// remove the invisible children from main list
		count = iEntries->Count();
		while (count-->=1)
			if (!iEntries->At(count)->Entry().Visible())
			{
			delete iEntries->At(count);
			iEntries->Delete(count);
			}
		}
	else
		{
		// keep old variable
		CArrayPtrFlat<CMsvClientEntry>* oldEntries = iEntries;
		iEntries=NULL;
		CMsvEntryArray* oldSortedChildren = iSortedChildren;
		iSortedChildren=NULL;
		TMsvSelectionOrdering oldOrder = iOrdering;	
		
		iOrdering = aOrdering;
		TRAPD(leave, DoSortTypeL(oldEntries->At(0)));

		if (leave)
			{
			// we left, the function may have created a new iEntries,
			// if iEntries has been created we need to delete all the elements
			// except the first one, that is used in the old list
			// then delete iEntries, and put back the old one.

			if(iEntries!=NULL)
				{
				if(iEntries->Count()!=0) 
					iEntries->Delete(0);
				iEntries->ResetAndDestroy();
				delete iEntries;
				}
			iEntries = oldEntries;

			// iSortedChildren doesn't own the children so just delete the new one.
			// and put the old one back.
			delete iSortedChildren;
			iSortedChildren = oldSortedChildren;
			iOrdering = oldOrder;
			User::Leave(leave);
			}
		else
			{
			oldEntries->Delete(0); // the object is used in new list
			oldEntries->ResetAndDestroy();
			delete oldEntries;
			delete oldSortedChildren;
			}
		}
	}



void CMsvEntry::DoSortTypeL(CMsvClientEntry* aContext)
//
// 
//
	{
	iEntries = new(ELeave) CArrayPtrFlat<CMsvClientEntry>(KMsvClientEntryArrayGranuality);
	iEntries->AppendL(aContext);

	iSortedChildren = CMsvEntryArray::NewL(*iMtmList);

	DoGetChildrenL();
	}



EXPORT_C void CMsvEntry::SetMtmListL(const CArrayFix<TUid>& aMtmList)
//
// Sets the mtm list
// If this leaves the mtm list has not been changed
//
/** Sets the MTM order to the specified sort order. When children of an entry are 
sorted, entries belonging to the same MTM type can be grouped together. 

MTM grouping can be switched on or off through setting the appropriate TMsvSelectionOrdering 
value by SetSortTypeL(). 

If the function leaves, the sort order is unchanged.

@param aMtmList The order of MTMs to use for sorting 
@leave KErrNoMemory Insufficient memory to resort the entries */
	{
	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));

	// create new mtm list
	CArrayFixFlat<TUid>* mtmList = new(ELeave)CArrayFixFlat<TUid>(KMsvMtmListGranularity);
	CleanupStack::PushL(mtmList);
	mtmList->InsertL(0, &aMtmList.At(0), aMtmList.Count());

	// create new sorted children list
	CMsvEntryArray* newSortedChildren = GetNewSortedListL(iOrdering, *mtmList);
	
	// install the new sorted children array
	delete iSortedChildren;
	delete iMtmList;
	iSortedChildren = newSortedChildren;
	iMtmList = mtmList;
	
	CleanupStack::Pop(); // mtmList
	}


TBool CMsvEntry::IsAChild(TMsvId aId) const
//
// Returns true if the entry is a child
//
	{
	TInt count=iSortedChildren->Count();
	while (count--)
		{
		if (iSortedChildren->At(count)->Id()==aId)
			return ETrue;
		}
	return EFalse;
	}

TBool CMsvEntry::AreChildren(const CMsvEntrySelection& aSelection) const
//
// Returns true if all the entries are children
//
	{
	TInt count = aSelection.Count();
	if(!count)
	    {
        return EFalse;
	    }
	else
	    {
        while (count--)
            {
            if (!IsAChild(aSelection.At(count)))
                {
                return EFalse;
                }
            }
	    }
	return ETrue;
	}


EXPORT_C TBool CMsvEntry::HasStoreL() const
/** Checks if the context has an associated message store.

@return ETrue: entry has a message store EFalse: entry does not have a message 
store */
	{
#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)
	if(iMsvSession.StoreManager().DoesAnyStoreExists(iEntryPtr->Id(), this->Entry().iMtm))
		return ETrue;
	else
		return iMsvSession.StoreManager().FileStoreExistsL(iEntryPtr->Id());
#else
	return iMsvSession.StoreManager().FileStoreExistsL(iEntryPtr->Id());
#endif
	}

/** Sets or clears multiple fields in a selection of children of the context.

Fields to change are specified using a bitmask of TMsvAttribute values. Possible 
fields that can be changed using this function are the PC synchronisation, Visibility, 
Pending Deletion, Read, In-preparation, Connected, and New flags. 

@param aSelection The entries to change
@param aSetAttributes A bitmask of the fields to set
@param aClearAttributes A bitmask of the fields to clear
@leave KErrNotFound An entry was not a child of the context
@see CMsvSession::ChangeAttributesL() 
*/
EXPORT_C void CMsvEntry::ChangeAttributesL(const CMsvEntrySelection& aSelection, TUint aSetAttributes, TUint aClearAttributes)
	{
#ifndef _NO_SESSION_LOGGING_
	Log(_L("ChangeAttributesL")); 
#endif

	__ASSERT_DEBUG(iState==EValid || iState==EInvalidDeletedContext || iState==EInvalidChangingContext, PanicServer(EMsvEntryStateUndetermined));
	__ASSERT_DEBUG(aSelection.Count(), PanicServer(EMsvEmptySelection));

	if (!AreChildren(aSelection))
		User::Leave(KErrNotFound);

	iMsvSession.Session().ChangeAttributesL(aSelection, aSetAttributes, aClearAttributes);
	}

