/*

* Copyright (c) 2006 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:  BIO control for handling remote drive configurations as 

*                smart messages

*

*/

// INCLUDE FILES

#include <biocmtm.h>					// for CBIOClientMtm

#include <msgbiocontrolObserver.h>		// for MMsgBioControlObserver

#include <StringLoader.h>				// for StringLoader

#include <CRichBio.h>               	// CRichBio

#include <aknnotewrappers.h>			// for CAknInformationNote

#include <mmsvattachmentmanager.h>

#include <utf.h> // for CnvUtfConverter

#include <rsfwmountman.h>

#include <rsfwmountentry.h>

#include <rsfwmountconfbc.rsg>              // for resouce identifiers

#include "rsfwmountconfbc.h"				

#include "rsfwmountconfbc.hrh"

#include "rsfwmountutils.h"

#include "rsfwgsplugin.hrh"

#include "rsfwnotpluginnamedialog.h"

#include "mdebug.h"

#define KUidGeneralSettings   0x100058EC

enum TOptionListLocation

	{

	EFirstMenuItem	= 0,

	ESecondMenuItem,

	EThirdMenuItem,

	EFourthMenuItem

	};

const TInt KMConfBcHeightReductionBva = 9;

_LIT(KMountConfBcResourceFile, "rsfwmountconfbc.rsc");

_LIT(KAvkonResourceFile, "avkon.rsc");

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// constructor

// ---------------------------------------------------------------------------

//

EXPORT_C CMsgBioControl* CRsfwMountConfBioControl::NewL(

		MMsgBioControlObserver& aObserver,

		CMsvSession* aSession,

		TMsvId aId,

		TMsgBioMode aEditorOrViewerMode,

		const RFile* aFile)

	{

	CRsfwMountConfBioControl* self =

		new(ELeave) CRsfwMountConfBioControl(aObserver,

										 aSession,

										 aId,

										 aEditorOrViewerMode,

										 aFile);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

// ---------------------------------------------------------------------------

// destructor

// ---------------------------------------------------------------------------

//

CRsfwMountConfBioControl::~CRsfwMountConfBioControl()

	{	

    delete iViewer;

	if (iMountEntry) 						

		{

		delete iMountEntry;

		}

	delete iMountMan;

	}

// ---------------------------------------------------------------------------

// constructor

// ---------------------------------------------------------------------------

//

CRsfwMountConfBioControl::CRsfwMountConfBioControl(

		 MMsgBioControlObserver& aObserver,

		 CMsvSession* aSession,

		 TMsvId aId,

		 TMsgBioMode aEditorOrViewerMode,

		 const RFile* aFile):

		 CMsgBioControl(aObserver,

						aSession,

						aId,

						aEditorOrViewerMode,

						aFile)

	{

	}

// ---------------------------------------------------------------------------

// second phase constructor

// ---------------------------------------------------------------------------

//

void CRsfwMountConfBioControl::ConstructL()

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::ConstructL"));

	iMountMan = CRsfwMountMan::NewL(0, NULL);

	iIsFileBased = IsFileBased();

	LoadResourceL(KMountConfBcResourceFile);

	LoadResourceL(KAvkonResourceFile);

	LoadResourceL(KNotPluginResourcePath);

    LoadStandardBioResourceL();

	// file handle to the remote drive configuration attachment in msv store

	RFile fileHandle;

    ResolveFileL( fileHandle );

    CleanupClosePushL( fileHandle );

	// read stream

    RFileReadStream stream( fileHandle,0 );

    CleanupClosePushL( stream );

	MStreamBuf* buf = stream.Source();

    buf->PushL();

    User::LeaveIfNull(buf);

    TInt bufferSize = buf->SizeL();

    if (bufferSize == 0 || (bufferSize < KMountMessagePrefixLength))

        {

        User::Leave(KErrMsgBioMessageNotValid);

        }

    TRequestStatus status;    

	HBufC8* utf8configuration = HBufC8::NewMaxLC(bufferSize);

	TPtr8 utfPtr = utf8configuration->Des();

	buf->ReadL(utfPtr, status);

	User::WaitForRequest(status);

	HBufC* unistring(NULL); 

	unistring = CnvUtfConverter::ConvertToUnicodeFromUtf7L(*utf8configuration);

	CleanupStack::PushL(unistring);

	RsfwMountUtils::ImportMountEntryL(*unistring,&iMountEntry);

	iViewer = new (ELeave) CRichBio(ERichBioModeEditorBase);

	FillViewerWithDataL();

	CleanupStack::PopAndDestroy(5,&fileHandle); 						 	

	}

// ---------------------------------------------------------------------------

// Formats displaying a remote drive (only the drive name is shown)

// ---------------------------------------------------------------------------

//

void CRsfwMountConfBioControl::FillViewerWithDataL()

    {

    DEBUGSTRING16(("CRsfwMountConfBioControl::FillViewerWithDataL"));

   	AddItemL(R_STR_SETTING_ITEM_DRIVE_NAME, *(*iMountEntry).Item(EMountEntryItemName));

    }

// ---------------------------------------------------------------------------

// Display a single item

// ---------------------------------------------------------------------------

//	

void CRsfwMountConfBioControl::AddItemL(TInt aLabelRes, const TDesC& aValue)

    {

    DEBUGSTRING16(("CRsfwMountConfBioControl::AddItemL"));	

    // Empty fields are not shown.

    if (&aValue) 

    	{

    	if (aValue.Length())

            {

            HBufC* labelTxt = StringLoader::LoadLC(aLabelRes, iCoeEnv);

            iViewer->AddItemL(*labelTxt, aValue);

            CleanupStack::PopAndDestroy(labelTxt);

            }

    	}

    }

void CRsfwMountConfBioControl::SetAndGetSizeL(TSize& aSize)

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::SetAndGetSizeL"));		

	if(iIsFileBased)

    	{

    	SetPosition(TPoint(0,KMConfBcHeightReductionBva));

    	aSize.iHeight -= KMConfBcHeightReductionBva;

    	iViewer->SetAndGetSizeL(aSize);

    	}

    else

    	{

    	iViewer->SetAndGetSizeL(aSize);

    	}

    SetSizeWithoutNotification(aSize);

	}

// ---------------------------------------------------------------------------

// Adds Save command to "Options" set

// ---------------------------------------------------------------------------

//

void CRsfwMountConfBioControl::SetMenuCommandSetL(CEikMenuPane& aMenuPane)

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::SetMenuCommandSetL"));			

	if (!IsEditor())

        {

   	    if( iIsFileBased )

            {

            FileBasedAddMenuItemL(aMenuPane, R_SM_SAVE,

                EMountConfBcCmdSave);

            }

        else

            {

            AddMenuItemL(aMenuPane, R_SM_SAVE,

                EMountConfBcCmdSave, EFirstMenuItem);

            }

        }

	}

void CRsfwMountConfBioControl::FileBasedAddMenuItemL(CEikMenuPane& aMenuPane,

    TInt aStringRes, TInt aCommandOffset)

    {

		DEBUGSTRING16(("CRsfwMountConfBioControl::FileBasedAddMenuItemL"));		   	

    CEikMenuPaneItem::SData menuItem;

    menuItem.iCascadeId = NULL;

    menuItem.iFlags = NULL;

    HBufC* string = StringLoader::LoadL(aStringRes, iCoeEnv);

    menuItem.iText.Format(*string);

    delete string;

    menuItem.iCommandId = iBioControlObserver.FirstFreeCommand()

        + aCommandOffset;

    aMenuPane.InsertMenuItemL(menuItem, 0);

    }

TRect CRsfwMountConfBioControl::CurrentLineRect() const

	{

		DEBUGSTRING16(("CRsfwMountConfBioControl::CurrentLineRect"));			

  	return iViewer->CurrentLineRect();

	}

TBool CRsfwMountConfBioControl::IsFocusChangePossible(

		TMsgFocusDirection aDirection) const

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::IsFocusChangePossible"));		

   	if (aDirection == EMsgFocusUp)

        {

        return iViewer->IsCursorLocation(EMsgTop);

        }

    return EFalse;

	}

// ---------------------------------------------------------------------------

// Sets the header or the remote drive view

// ---------------------------------------------------------------------------

//

HBufC* CRsfwMountConfBioControl::HeaderTextL() const

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::HeaderTextL"));				

	return StringLoader::LoadL(R_SM_TITLE_MOUNT_CONF, iCoeEnv);

	}

// ---------------------------------------------------------------------------

// Handles the command selected by the user

// ---------------------------------------------------------------------------

//

TBool CRsfwMountConfBioControl::HandleBioCommandL(TInt aCommand)

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::HandleBioCommandL %d", aCommand));

	aCommand -= iBioControlObserver.FirstFreeCommand();

	switch (aCommand)

		{

	case EMountConfBcCmdSave:

    	TRAPD(err, DoMountL(iMountEntry));	

        if (!err) 

	        {

		    HBufC* buf = StringLoader::LoadLC(R_SM_SUCCESS_MOUNT);

            CAknConfirmationNote* note = new (ELeave) CAknConfirmationNote;

            note->ExecuteLD(*buf);

	        CleanupStack::PopAndDestroy(buf);	

	        }

	    else if (KErrInUse == err) 

	        {

	        HBufC* buf = StringLoader::LoadLC(R_SM_TOO_MANY_REMOTE_DRIVES);

            CAknErrorNote* note = new (ELeave) CAknErrorNote;

            note->ExecuteLD(*buf);

	        CleanupStack::PopAndDestroy(buf);	

	        }

	    else if (!(KErrCancel == err)) 

	        {

	        // cancel means that user does not want to rename

	        User::Leave(err);

	        }

	    return ETrue;

	default:

		return EFalse;

		}

	}

TKeyResponse CRsfwMountConfBioControl::OfferKeyEventL(

		const TKeyEvent& aKeyEvent,

		TEventCode aType)

	{

DEBUGSTRING16(("CRsfwMountConfBioControl::OfferKeyEventL"));		

	return iViewer->OfferKeyEventL(aKeyEvent, aType);

	}

TInt CRsfwMountConfBioControl::CountComponentControls() const

	{

DEBUGSTRING16(("CRsfwMountConfBioControl::CountComponentControls"));			

 	return 1; // the viewer component

	}

CCoeControl* CRsfwMountConfBioControl::ComponentControl(TInt aIndex) const

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::ComponentControl"));		

    if (aIndex == 0)

        {

        return iViewer;

        }

    return NULL;

	}

void CRsfwMountConfBioControl::SizeChanged()

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::SizeChanged"));		

	iViewer->SetExtent(Position(), iViewer->Size());

	}

void CRsfwMountConfBioControl::FocusChanged(TDrawNow /* aDrawNow */)

	{

	DEBUGSTRING16(("CRsfwMountConfBioControl::FocusChanged"));				

 	iViewer->SetFocus(IsFocused());

	}

void CRsfwMountConfBioControl::SetContainerWindowL(const CCoeControl& aContainer)

	{

		DEBUGSTRING16(("CRsfwMountConfBioControl::SetContainerWindowL"));			

	CCoeControl::SetContainerWindowL(aContainer);

    // The reason for creating the viewer control here is that the

    // construction of the viewer requires a parent with a window. So it

    // cannot be done in ConstructL().

    //

    iViewer->ConstructL(this);

	}

TInt CRsfwMountConfBioControl::VirtualHeight()

	{

		DEBUGSTRING16(("CRsfwMountConfBioControl::VirtualHeight"));			

 	return iViewer->VirtualHeight();

	}

TInt CRsfwMountConfBioControl::VirtualVisibleTop()

	{

		DEBUGSTRING16(("CRsfwMountConfBioControl::VirtualVisibleTop"));				

	return iViewer->VirtualVisibleTop();

	}

TBool CRsfwMountConfBioControl::IsCursorLocation(TMsgCursorLocation aLocation) const

    {

 		DEBUGSTRING16(("CRsfwMountConfBioControl::IsCursorLocation"));			   	

    return iViewer->IsCursorLocation(aLocation);

    }

void CRsfwMountConfBioControl::ResolveFileL( RFile& aFile )

    {

  		DEBUGSTRING16(("CRsfwMountConfBioControl::ResolveFileL"));	   	

    if ( iIsFileBased )

        {

		aFile.Duplicate(FileHandle());

        }

    else

        {

        CMsvEntry* entry = MsvSession().GetEntryL( iId );

        CleanupStack::PushL( entry );

		CMsvStore* store = entry->ReadStoreL();

		CleanupStack::PushL(store);

		MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

		aFile = attachMan.GetAttachmentFileL( 0 ); //entry is the first attachment

		CleanupStack::PopAndDestroy( 2, entry ); // store, entry

        }

    }

// ---------------------------------------------------------------------------

// Saves the selected remote drive to the Central Repository table

// ---------------------------------------------------------------------------

//

void CRsfwMountConfBioControl::DoMountL(CRsfwMountEntry* aMounterEntry)

	{

  		DEBUGSTRING16(("CRsfwMountConfBioControl::DoMountL"));	   		

	// CRsfwMountEntry API ensures that EMountEntryItemName

	// length does not exceed KMaxFriendlyNameLength characters	

	TBuf<KMaxFriendlyNameLength>  newFriendlyName;

    newFriendlyName.Copy(*aMounterEntry->Item(EMountEntryItemName));

    TBool nameUnique = EFalse;

    TBool operationCancelled = EFalse;

    nameUnique = isNameUniqueL(newFriendlyName);

    while ((!nameUnique) && (!operationCancelled)) 

        {

        operationCancelled = GetNameForNewMountL(newFriendlyName);

        nameUnique = isNameUniqueL(newFriendlyName);

        }

    if (!operationCancelled) 

        {

        // clone the entry and add it to the cenrep

        // we clone it so that the original smart message content does not change

        CRsfwMountEntry* entrytoBeSaved = aMounterEntry->CloneL();

        // copy newFriendlyName to name

        entrytoBeSaved->SetItemL(EMountEntryItemName, newFriendlyName);

        // set mountentryindex to -1 so that this will go the end of the list

        TBuf<5> index;

   	    index.Num(-1);

   	    entrytoBeSaved->SetItemL(EMountEntryItemIndex, index);	

   	    // ownership is transferred to MountMan

	    iMountMan->AddMountEntryL(entrytoBeSaved);

        }

    else 

        {

        User::Leave(KErrCancel);

        }

	}

// ---------------------------------------------------------------------------

// Tests whether the chosen remote drive name is unique

// ---------------------------------------------------------------------------

//

TBool CRsfwMountConfBioControl::isNameUniqueL(const TDesC& aName)

    {

  		DEBUGSTRING16(("CRsfwMountConfBioControl::isNameUniqueL"));	    	

    // figure out whether a drive with the same name already exists

	CDesCArray* driveArray = new (ELeave) CDesC16ArraySeg(4);

	CleanupStack::PushL(driveArray);

	iMountMan->GetMountNamesL(driveArray); 

	// report error if there are already 9 remote drives

	if (driveArray->Count() == KMaxRemoteDrives) 

	    {

	    CleanupStack::PopAndDestroy(driveArray);

	    User::Leave(KErrInUse);

	    }

    for (int i = 0; i < driveArray->Count(); i++) 

        {

        if (aName == driveArray->MdcaPoint(i)) 

            {

            // there was a match and the name is not unique

            CleanupStack::PopAndDestroy(driveArray);

            return EFalse;

            }

        }

    CleanupStack::PopAndDestroy(driveArray);    

    return ETrue;    

    }

// ---------------------------------------------------------------------------

// Queries new remote drive name from the user

// ---------------------------------------------------------------------------

//

TBool CRsfwMountConfBioControl::GetNameForNewMountL(TDes& aName)	

    {

  		DEBUGSTRING16(("CRsfwMountConfBioControl::GetNameForNewMountL"));	    	

    TBool operationCancelled = EFalse; 

    // ask user to change the name and try again

    HBufC* confmess = StringLoader::LoadLC(R_STR_NAME_RENAME_QUERY, aName);

    CAknQueryDialog* query = CAknQueryDialog::NewL

                                        (CAknQueryDialog::EConfirmationTone);

	if (query->ExecuteLD( R_CONFIRMATION_QUERY, *confmess)) 

	    {

	    TBuf<KMaxFriendlyNameLength> newName;

	    TBool retval;

	    // for getting the new name, use name dialog from the "global save as dialog"

	    HBufC* defaultname = StringLoader::LoadLC(R_SM_DEFAULT_DRIVE_NAME);

        CRsfwNotPluginNameDialog* dlg = 

                CRsfwNotPluginNameDialog::NewL( 

               *defaultname, newName, iEikonEnv->FsSession());

        dlg->SetMaxLength(KMaxFriendlyNameLength);

        dlg->PrepareLC( R_FILE_NAME_QUERY );

        retval = dlg->RunLD();

        CleanupStack::PopAndDestroy(defaultname);

        if (!retval) 

            {

            // user cancelled renaming

            operationCancelled = ETrue;

            }

         else 

            {

            aName = newName;

            }

	    }

	else 

	    {

	    // user does not want to rename

	    operationCancelled = ETrue;

	    }

    CleanupStack::PopAndDestroy(confmess);      

	return operationCancelled;