/*
* Copyright (c) 2002 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:     A utility that provides services to both the Speeddial and
*                PhoneBook applications for getting and setting speeddial
*                number configuration.
*
*/







// INCLUDE FILES
#include <akninputblock.h>
#include <bldvariant.hrh>
#include <gulicon.h>
#include <akncontext.h>
#include <akntitle.h>
#include <AknQueryDialog.h>
#include <aknlists.h>
#include <bautils.h>
#include <aknnotedialog.h>
#include <aknnotecontrol.h>
#include <aknnotewrappers.h>
#include <sysutil.h>
#include <ErrorUI.h>
#include <vmnumber.h>
#include <centralrepository.h>
#include <SettingsInternalCRKeys.h>
#include <SpeeddialPrivateCRKeys.h>


#include <StringLoader.h>
#include <Spdctrl.rsg>
#include <spdctrl.mbg>
#include <avkon.mbg>
#include <gdi.h>
#include <AknIconArray.h>

#include <aknlayoutscalable_apps.cdl.h>
#include <layoutmetadata.cdl.h>
#include <AknsBasicBackgroundControlContext.h>
#include <AknsDrawUtils.h>
#include <AknsUtils.h>
#include <AknIconUtils.h>
#include <applayout.cdl.h>
#include <data_caging_path_literals.hrh>
#include <f32file.h>
#include <featmgr.h>
#include "SpdiaGridVPbk.h"
#include "SpdiaGridDlgVPbk.h"
#include "SpdiaIndexDataVPbk.h"
#include "SpdiaControl.hrh"
#include "Speeddial.laf"
#include "SpdiaPanic.h"

#include "speeddialprivate.h"
#include <CVPbkFieldTypeRefsList.h>
#include <MPbk2FieldPropertyArray.h>
#include <TPbk2IconId.h>
#include <MVPbkContactOperationBase.h>
#include <Pbk2FieldPropertiesFactory.h>
#include <MPbk2FieldProperty.h>
#include <CVPbkSpeedDialAttribute.h>
#include <MVPbkContactFieldTextData.h>
#include <MVPbkContactFieldUriData.h>
#include <CVPbkContactFieldIterator.h>
#include <CPbk2IconFactory.h>
#include <CPbk2SortOrderManager.h>
#include <MPbk2ContactNameFormatter.h>
#include <Pbk2ContactNameFormatterFactory.h>
#include <CVPbkFieldTypeSelector.h>
#include <VPbkContactViewFilterBuilder.h>
#include <CVPbkContactStoreUriArray.h>
#include <TVPbkContactStoreUriPtr.h>
#include <CVPbkContactLinkArray.h>
#include <MVPbkContactStoreList.h>
#include <MVPbkContactStore.h>
#include <MVPbkContactLink.h>
#include <CVPbkContactLinkArray.h>
#include <MVPbkContactStoreProperties.h>
#include <voicemailboxdomaincrkeys.h>
#include <AiwGenericParam.h>
#include <AiwServiceHandler.h>
#include <telvmbxsettingscrkeys.h>

#include <VPbkEng.rsg>
#include <AiwContactAssignDataTypes.h>

#include "SpdiaContainer.h"

// LOCAL CONSTANTS AND MACROS
//This order is based on 'Standard field ids' (PbkFields.hrh)

const TUint KFieldIds[] = 
{
    R_VPBK_FIELD_TYPE_LANDPHONEHOME,
    R_VPBK_FIELD_TYPE_MOBILEPHONEHOME,
    R_VPBK_FIELD_TYPE_VIDEONUMBERHOME,
    R_VPBK_FIELD_TYPE_FAXNUMBERHOME,
    R_VPBK_FIELD_TYPE_VOIPHOME,
    R_VPBK_FIELD_TYPE_LANDPHONEWORK,
    R_VPBK_FIELD_TYPE_MOBILEPHONEWORK,
    R_VPBK_FIELD_TYPE_VIDEONUMBERWORK,
    R_VPBK_FIELD_TYPE_FAXNUMBERWORK,
    R_VPBK_FIELD_TYPE_VOIPWORK,
    R_VPBK_FIELD_TYPE_LANDPHONEGEN,
    R_VPBK_FIELD_TYPE_MOBILEPHONEGEN,
    R_VPBK_FIELD_TYPE_VIDEONUMBERGEN,
    R_VPBK_FIELD_TYPE_FAXNUMBERGEN,
    R_VPBK_FIELD_TYPE_VOIPGEN,
    R_VPBK_FIELD_TYPE_POC,
    R_VPBK_FIELD_TYPE_SWIS,
    R_VPBK_FIELD_TYPE_PAGERNUMBER,
    R_VPBK_FIELD_TYPE_ASSTPHONE,
    R_VPBK_FIELD_TYPE_CARPHONE,
    R_VPBK_FIELD_TYPE_IMPP
};



const TInt KCellRowCount(3);
const TInt KCellColCount(3);
const TInt KMaxIndex(8);
const TInt KVoiceMail(0);


const TInt KLayoutCount(5);
const TInt KNullIndexData(-1);
const TInt32 KVmbxUid(0x100058F5) ;
const TInt KOperatorNameLength(100);
const TInt KContactFormattingFlags = MPbk2ContactNameFormatter::EPreserveLeadingSpaces | MPbk2ContactNameFormatter::EReplaceNonGraphicChars;

_LIT(KNullCell, "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t%d\t");
_LIT(KDesTab, "\t");
_LIT(KDesTab2, "\t\t");




// ---------------------------------------------------------
// CSpeedDialPrivate::NewL()
// ---------------------------------------------------------
//
	

	EXPORT_C CSpeedDialPrivate*	CSpeedDialPrivate::NewL(CVPbkContactManager* aContactManager )
	{
		CSpeedDialPrivate* self = new(ELeave) CSpeedDialPrivate(aContactManager);
		CleanupStack::PushL(self);
    	self->ConstructL();
    	CleanupStack::Pop();  // self
    	return self;
	}

// ---------------------------------------------------------
// CSpdiaControl::CSpdiaControl
//
// ---------------------------------------------------------
//

	CSpeedDialPrivate::CSpeedDialPrivate(CVPbkContactManager* aContactManager):
                        iShadowLayout(NULL),
                        iBgContext(NULL),
                        iCurrentIndex( -1 ),
                        iDialSkinBmp(NULL),
                        iSkinIcons(NULL),
                        iContactManager(aContactManager),
                        iImageManager(NULL),
                        iContactLink(NULL),
                        iContact(NULL),
                        iContactLinkArray(NULL),
                        iSpeedDial(NULL),
                        iUpdateFlag(EFalse),
                        iSdmArray(NULL),
                        iWait(NULL),
                        iVideoMail(0),
                        iMail(NULL),
                        iFetchmail(EFalse),
                        iServiceHandler(NULL),						
                        iCancelFlag(0),
                        iRemoveConfirmQueryDialog( NULL )
                        /*iOperationComplete(EFalse),*/
	{

	}

// ---------------------------------------------------------
// CSpeedDialPrivate::ConstructL
//
// ---------------------------------------------------------
//
	void CSpeedDialPrivate::ConstructL()
	{
		 TInt tmp = 1;

	   	_LIT(KMbmFileName, "Z:spdctrl.mbm");
		_LIT(KRscFileName, "Z:spdctrl.rsc" );

		TParse* fpMbm = new(ELeave) TParse ();
		fpMbm->Set (KMbmFileName, &KDC_APP_BITMAP_DIR, NULL);
		iBmpPath.Copy(fpMbm ->FullName());
		delete fpMbm;
		fpMbm=NULL;

		TParse* fpRsc = new(ELeave) TParse ();
		fpRsc->Set (KRscFileName, &KDC_RESOURCE_FILES_DIR, NULL);
		
		TBuf<254> rscPath;
		rscPath.Copy(fpRsc ->FullName());
		
		delete fpRsc;
		fpRsc=NULL;

		CRepository* repository = CRepository::NewLC(KCRUidSpeedDialLV);
		repository->Get( KSpeedDialLVFlags, tmp );

		iBooleanVarForAddingDialogVariation  = ( tmp == 1);
		
		CleanupStack::PopAndDestroy(); // pop-destroy repository


	    TFileName fileName(rscPath);
	    BaflUtils::NearestLanguageFile(iCoeEnv->FsSession(), fileName);
	    iFileOffset = iCoeEnv->AddResourceFileL(fileName);

	    iSdmCount = KCellRowCount * KCellColCount;
	    iGridUsed = EGridNoUse;

	    iIconArray = new (ELeave)CAknIconArray(iSdmCount);
	    iSdmArray = new (ELeave) CArrayFixFlat<TSpdiaIndexDataVPbk>(iSdmCount);
	    TSpdiaIndexDataVPbk spDialData;
	    iSdmArray->AppendL(spDialData, iSdmCount);

		iDialSkinBmp = new (ELeave)RArray<TAknsItemID>(KArraySize);
		iSkinIcons = new (ELeave)RArray<TAknsItemID>(KArraySize);
	    iShadowLayout = new (ELeave) CArrayFixFlat<TAknLayoutRect> (KLayoutCount);
	    for (TInt i(0); i < KLayoutCount; ++i)
	        {
	        TAknLayoutRect rect;
	        iShadowLayout->AppendL(rect);
	        }

			
		iSpeedDial = CVPbkSpeedDialAttribute::NewL();
		
		iAttributeManager = &(iContactManager->ContactAttributeManagerL());

		iThumbNailFieldType = iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_THUMBNAILPIC ); 
		iImageManager =  CPbk2ImageManager::NewL(*iContactManager);
		iContactLinkArray = NULL;
	    iServiceHandler = CAiwServiceHandler::NewL();
		iServiceHandler->AttachL( R_SPEEDDIAL_EMAIL_SELECTION_INTEREST );
		iServiceHandler->AttachL( R_SPDIA_SINGLE_ASSIGN_INTEREST );
		iWait = new( ELeave )CActiveSchedulerWait();
		
		
		iError = KErrNone;

        MVPbkContactStoreList& storeList = iContactManager->ContactStoresL();
        for(TInt count=0;count<storeList.Count();++count)
        {
        	iOperationComplete = EFalse;
        	storeList.At(count).OpenL(*this);
        	while(!iOperationComplete)
	        {	
	   			Wait();
	        }
        }
   
        
	    InitIndexDataL();
	    
	    iState = STATE_IDLE;
	    
		InitializeArray();

	    // create skin context
	    // Size is set in SizeChanged()
	    iBgContext = CAknsBasicBackgroundControlContext::NewL(
	        KAknsIIDQsnBgAreaMainQdial,
	        TRect(0,0,0,0),
	        EFalse );
	        iPopupDialog = EFalse;

 	ivmbxvariation = CRepository::NewL( KCRUidVideoMailbox );
	ivmbxvariation->Get( KVideoMbxSupport, iVmbxsupported );
	
	
	CRepository*  vmbxkey2 = CRepository::NewL( KCRUidTelVideoMailbox );
    vmbxkey2->Get( KTelVideoMbxKey, iVmbxkeypos );
	delete vmbxkey2;
	vmbxkey2 = 	NULL      ;
	// Initialize the bmp arrays
	InitBmpArray();
//#ifndef VIDEOMAILBOX_HIDDEN//its shown
if(iVmbxsupported)
	{
	    iType = EVmbx;
	}
	
else
        iType = EVmbx;
	 iShowAssignCalled = EFalse;
		
	}


// ---------------------------------------------------------
// CSpeedDialPrivate::InitBmpArray
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::InitBmpArray()
{
		TInt i(0);
		
		// Possible values for iVmbxkeypos are 1 & 2
		(iVmbxkeypos > 1) ? iVideoMail = 1 : iVideoMail = 0;
		
		 // Initialize grid bitmaps
		 for (i = 0; i < 9; i++ )
		 {
		 	// EMbmSpdctrlQgn_graf_quick_one
		 	if (0 == i)
		 	{
		 		
		 		#ifdef __SCALABLE_ICONS
				    iDialBmp[0] 	= EMbmSpdctrlQgn_menu_smsvo;
				    iDialBmpMask[0]	= EMbmSpdctrlQgn_menu_smsvo_mask;
				    
				    iDialHindiBmp[0] 		= EMbmSpdctrlQgn_menu_smsvo;
				    iDialHindiBmpMask[0]	= EMbmSpdctrlQgn_menu_smsvo_mask;
				#else
				    iDialBmp[0] = EMbmSpdctrlQgn_menu_smsvo_lst;
				    iDialBmp[0] = EMbmSpdctrlQgn_menu_smsvo_lst_mask;
				    
				    iDialHindiBmp[0] 		= EMbmSpdctrlQgn_menu_smsvo_lst;
				    iDialHindiBmpMask[0]	= EMbmSpdctrlQgn_menu_smsvo_lst_mask;
				#endif
				
				continue;
		 	}
			
			// EMbmSpdctrlQgn_graf_quick_two
			if (1 == i)
			{
				// If Video Mailbox is via key2, then update with corresponding icons 
				// in the 2nd location of the grid.
				if ((0 < iVideoMail) &&(iVmbxsupported))
				{
					iDialBmp[1] 	= EMbmSpdctrlQgn_prop_video_mb;
					iDialBmpMask[1] = EMbmSpdctrlQgn_prop_video_mb_mask;
					
					iDialHindiBmp[1] 		= EMbmSpdctrlQgn_prop_video_mb;
					iDialHindiBmpMask[1] 	= EMbmSpdctrlQgn_prop_video_mb_mask;
				}
				// (else) VideoMailbox is via key 0
				else
				{
					iDialBmp[1] 	= EMbmSpdctrlQgn_graf_quick_two;
					iDialBmpMask[1] = EMbmSpdctrlQgn_graf_quick_two_mask;
					
					iDialHindiBmp[1] 		= EMbmSpdctrlQgn_graf_deva_quick_two;
					iDialHindiBmpMask[1] 	= EMbmSpdctrlQgn_graf_deva_quick_two_mask;
				}
				
				continue;
			}
			
			iDialBmp[i]		= EMbmSpdctrlQgn_menu_smsvo + (2 * i);
			iDialBmpMask[i]	= EMbmSpdctrlQgn_menu_smsvo + (2 * i) + 1;
			
			iDialHindiBmp[i]	= EMbmSpdctrlQgn_graf_deva_quick_one + (2 * i);
			iDialHindiBmpMask[i]= EMbmSpdctrlQgn_graf_deva_quick_one + (2 * i) + 1;
		 }

}

// ---------------------------------------------------------
// CSpeedDialPrivate::~CSpeedDialPrivate
//
// ---------------------------------------------------------
//
	EXPORT_C CSpeedDialPrivate::~CSpeedDialPrivate()
    {

	    //delete iThumbFactory;
	    delete iShadowLayout;
	    
	    if (iGridUsed == EGridNoUse)
	        {
	        if (iIconArray)
	            {
	            iIconArray->ResetAndDestroy();
	            delete iIconArray;
	            }
	        }
	        
	    ResetArray();
	    delete iSdmArray;
	    

	    if (iCoeEnv != NULL)
	        {
	        iCoeEnv->DeleteResourceFile(iFileOffset);
	        }
	    delete iBgContext;
	    
		if(iDialSkinBmp != NULL)
			{
			iDialSkinBmp->Close();
			delete iDialSkinBmp;
			}
		

		if(iSkinIcons !=  NULL)
			{
			iSkinIcons->Close();
			delete iSkinIcons;
			}
		
		TRAP_IGNORE(
				{
					MVPbkContactStoreList& storeList =  iContactManager->ContactStoresL();
           		
           			for(TInt count=0;count<storeList.Count();++count)
        			{
        				storeList.At(count).Close(*this);
        			}
				}
			);		
		
		delete iImageManager;
		delete iWait;
		delete iContact;
		delete iContactLinkArray;
		delete iSpeedDial;
		delete iQueryDialog;
		delete ivmbxvariation;
		if ( iServiceHandler )
			{
			delete iServiceHandler;
			iServiceHandler = NULL;
			}
    if ( iRemoveConfirmQueryDialog )
        {
        delete iRemoveConfirmQueryDialog;
        iRemoveConfirmQueryDialog = NULL;
        }
    }
       
// ---------------------------------------------------------
// CSpeedDialPrivate::InitializeArray
//
// ---------------------------------------------------------
//   
void CSpeedDialPrivate::InitializeArray()
    {
    iDialSkinBmp->Append(KAknsIIDQgnMenuSmsvoLst);
    iDialSkinBmp->Append(KAknsIIDQgnGrafQuickTwo);
    iDialSkinBmp->Append(KAknsIIDQgnGrafQuickThree);
    iDialSkinBmp->Append(KAknsIIDQgnGrafQuickFour);
    iDialSkinBmp->Append(KAknsIIDQgnGrafQuickFive);
    iDialSkinBmp->Append(KAknsIIDQgnGrafQuickSix);
    iDialSkinBmp->Append(KAknsIIDQgnGrafQuickSeven);
    iDialSkinBmp->Append(KAknsIIDQgnGrafQuickEight);
    iDialSkinBmp->Append(KAknsIIDQgnGrafQuickNine);

    iSkinIcons->Append(KAknsIIDQgnPropNrtypPhone);
    iSkinIcons->Append(KAknsIIDQgnPropNrtypHome);
    iSkinIcons->Append(KAknsIIDQgnPropNrtypWork);
    iSkinIcons->Append(KAknsIIDQgnPropNrtypMobile);
    iSkinIcons->Append(KAknsIIDQgnPropNrtypVideo);
    iSkinIcons->Append(KAknsIIDQgnPropNrtypFax);
    iSkinIcons->Append(KAknsIIDQgnPropNrtypPager);
    if ( FeatureManager::FeatureSupported( KFeatureIdCommonVoip ) )
        {
        iSkinIcons->Append( KAknsIIDQgnPropNrtypVoip );  
	}
    iSkinIcons->Append(KAknsIIDQgnPropNrtypEmail);
    iSkinIcons->Append(KAknsIIDQgnPropNrtypAddress);
    }

// ---------------------------------------------------------
// CSpeedDialPrivate::ResetArray
//
// ---------------------------------------------------------
//   
	void CSpeedDialPrivate::ResetArray()
    {
    	TInt index(0);
	    if(iSdmArray!= NULL)
	    {
	 	    
	    
	    for (index = 0; index < iSdmArray->Count(); index++)
	        {
	        (*iSdmArray)[index].Reset();
	        (*iSdmArray)[index].SetIndex(index);
	        }
	    }
    }
 
// ---------------------------------------------------------
// CSpeedDialPrivate::CreateFieldIconsL
//
// ---------------------------------------------------------
//      
	void CSpeedDialPrivate::CreateFieldIconsL(CArrayPtrFlat<CGulIcon>* aArray)
	{
		TInt arraySize = sizeof KFieldIds / sizeof KFieldIds[0];
		TInt count =0;
		const MVPbkFieldType* fieldType = NULL;
		CGulIcon* icon = NULL;
		
		CVPbkFieldTypeRefsList* fieldTypeList = CVPbkFieldTypeRefsList::NewL();
		CPbk2IconFactory* pbk2IconFactory = CPbk2IconFactory::NewL();

	
		for(count =0; count < arraySize;  ++count)
		{
			fieldType = iContactManager->FieldTypes().Find( KFieldIds[count] );
			fieldTypeList->AppendL(*fieldType);	
		}
		
		MPbk2FieldPropertyArray* aPropertyArray = Pbk2FieldPropertiesFactory::CreateLC(*fieldTypeList,&iContactManager->FsSession() );
		
		for(count =0; count < aPropertyArray->Count(); ++ count)
		{
		   icon = pbk2IconFactory->CreateIconL(aPropertyArray->At(count).IconId());
		   aArray->AppendL(icon);		   
		}
		
		CleanupStack::PopAndDestroy(aPropertyArray);
		
		delete fieldTypeList;
		delete pbk2IconFactory;
		
		
	}
// ---------------------------------------------------------
// CSpeedDialPrivate::VoiceMailL  
//
// ---------------------------------------------------------
//
EXPORT_C TBool CSpeedDialPrivate::VoiceMailL(TDes& aNumber)
    {
    TBool result(ETrue);

    RVmbxNumber vmbx;
    CleanupClosePushL(vmbx); // So that Close() is called if a leave happens.
    if (vmbx.Open() == KErrNone)
        {
        TInt err2 = vmbx.GetVideoMbxNumber( aNumber );

        
	if( iVmbxsupported )
		{
	        TInt err1 = vmbx.GetVmbxNumber( aNumber );
	        TInt err2 = vmbx.GetVideoMbxNumber( aNumber );
	                    
	    if ( ( err1 == KErrNotFound || err1 == KErrNotSupported ) &&
	         ( err2 == KErrNotFound || err2 == KErrNotSupported ))
	        {
	        iType = vmbx.SelectTypeL( EVmbxDefine );
	        }
	    else 
	        {
	        iType = vmbx.SelectTypeL( EVmbxCall );
	        }   
	        
	        if( iType == EVmbxIP && !vmbx.IsVoIPProfilesFound() )
	            {
				TInt err(vmbx.GetVmbxAddressL(aNumber));
		        if (err != KErrNone)
		            {
		            aNumber.Zero();
		            if (err != KErrNotFound ||
		                    !vmbx.QueryAddressL(EVmbxNotDefinedQuery, aNumber))
		                {
		                result = EFalse;
		                }
		            }
	        	}
	        else if( iType == EVmbxVideo )
	            {
				TInt err(vmbx.GetVideoMbxNumber(aNumber));
				if (err != KErrNone)
					{
					aNumber.Zero();
					if (err != KErrNotFound ||!vmbx.QueryVideoMbxNumberL(EVmbxNotDefinedQuery, aNumber))
						{
						result = EFalse;
						}
					}            
	            }
		    else if(iType ==EVmbx)
		    	{
				TInt err(vmbx.GetVmbxNumber(aNumber));
				if (err != KErrNone)
					{
					aNumber.Zero();
					if (err != KErrNotFound ||
	                    !vmbx.QueryNumberL(EVmbxNotDefinedQuery, aNumber))
						{
						result = EFalse;
						}
					}
	            }
	           else
	           {
	           	result = EFalse;
	           }
		}
	else
		{
		ExVoiceMailL(aNumber);
		
		}
       
        }
    CleanupStack::PopAndDestroy();  // It will call vmbx.Close()
    return result;
    }
    
// ---------------------------------------------------------
// CSpeedDialPrivate::ExVoiceMailL  
//
// ---------------------------------------------------------
//
EXPORT_C TBool CSpeedDialPrivate::ExVoiceMailL(TDes& aNumber)
    {
    TBool result(ETrue);
        RVmbxNumber vmbx;
    CleanupClosePushL(vmbx); // So that Close() is called if a leave happens.
  
  if (vmbx.Open() == KErrNone)
        {


    if( !vmbx.IsVoIPProfilesFound() && vmbx.SelectTypeL( EVmbxCall ) )
        	{
			iType = ETrue;
			TInt err(vmbx.GetVmbxAddressL(aNumber));
	        if (err != KErrNone)
	            {
	            if (err != KErrNotFound ||
	                    !vmbx.QueryAddressL(EVmbxNotDefinedQuery, aNumber))
	                {
	                result = EFalse;
	                }
	            }
        	}
	        else
	    	{
	    	iType = EFalse;
			TInt err(vmbx.GetVmbxNumber(aNumber));
			if (err != KErrNone)
				{
				if (err != KErrNotFound ||
                    !vmbx.QueryNumberL(EVmbxNotDefinedQuery, aNumber))
					{
					result = EFalse;
					}
				}
	    	}
       
        }
    CleanupStack::PopAndDestroy();  // It will call vmbx.Close()
    return result;
    }
    

// ---------------------------------------------------------
// CSpeedDialPrivate::ExVideoMailL  
//
// ---------------------------------------------------------
//
    
  EXPORT_C TBool CSpeedDialPrivate::ExVideoMailL(TDes& aNumber)
    {
     //TInt iVmbxsupported(0);
    
    TBool result(ETrue);


    RVmbxNumber vmbx;
    CleanupClosePushL(vmbx); // So that Close() is called if a leave happens.
    
    if(vmbx.Open() == KErrNone)
    {
        
    
//    if(vmbx.SelectTypeL( EVmbxCall )) 
    {
        
    
    iType = EVmbxVideo;

    TInt err2 = vmbx.GetVideoMbxNumber( aNumber );


//#ifndef VIDEOMAILBOX_HIDDEN
//ivmbxvariation->Get( KVideoMbxSupport, vmbxsupported );
if(iVmbxsupported)
{
	

	if (err2 == KErrNotFound)
	{

	aNumber.Zero();
	if (err2 != KErrNotFound ||!vmbx.QueryVideoMbxNumberL(EVmbxNotDefinedQuery, aNumber))
		{
		result = EFalse;
		}
	}         
	else
	{
	    result = ETrue;
	}  
}
else
    //Number is present and can be called
    if(err2 != KErrNotFound)
    {
        result = ETrue;
    }
    else
    {
        result = EFalse;
    }
    

    }
}
    CleanupStack::PopAndDestroy();  // It will call vmbx.Close()
    return result;
    }
// CSpeedDialPrivate::Index
//
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::Index(TInt aDial) const
    {
    return (aDial - 1);
    }

// ---------------------------------------------------------
// CSpeedDialPrivate::IconArray
// An interface for accessing index data array.
// ---------------------------------------------------------
//
EXPORT_C CArrayPtr<CGulIcon>* CSpeedDialPrivate::IconArray() const
    {
    return iIconArray;
    }

// ---------------------------------------------------------
// CSpeedDialPrivate::Contact
// ---------------------------------------------------------
//
 
EXPORT_C MVPbkStoreContact* CSpeedDialPrivate::Contact(TInt aIndex)
{
	return (*iSdmArray)[aIndex].Contact();
}
 
// ---------------------------------------------------------
// CSpeedDialPrivate::Number
// An interface for accessing index data array
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::Number(TInt aIndex) const
    {
    return (aIndex + 1);
    }
    
// ---------------------------------------------------------
// CSpeedDialPrivate::PhoneNumber
// An interface for accessing index data array.
// ---------------------------------------------------------
//
EXPORT_C const TDesC& CSpeedDialPrivate::PhoneNumber(TInt aIndex) const
    {
    return (*iSdmArray)[aIndex].PhoneNumber();
    }
    
// ---------------------------------------------------------
// CSpeedDialPrivate::ThumbIndex
// An interface for accessing index data array.
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::ThumbIndex(TInt aIndex) const
    {
    return (*iSdmArray)[aIndex].ThumbIndex();
    }
    
// ---------------------------------------------------------
// CSpeedDialPrivate::CreateGridDataL
//
// ---------------------------------------------------------
//
EXPORT_C TBool CSpeedDialPrivate::CreateGridDataL(
                CAknGrid* aGrid, TBool aIndex )
    {
    iGrid = aGrid;
    if ( iGridUsed == EGridNoUse )
        {
        iGridUsed = EGridUse;
        }

    // The specified index is updated.
    if ( ( aIndex >= 0 ) && ( aIndex <= KMaxIndex ) )
        {
        return UpdateIndexDataL( aIndex );
        }

    CDesCArray* array = STATIC_CAST( CDesCArray*, aGrid->Model()->ItemTextArray() );
    if ( aIndex == KNullIndexData )
    	{
    	InitIndexDataL();
    	}
    TInt thumbCount = SetIconArrayL( iIconArray );
    if ( thumbCount > 0 )
        {
        SetOperationsL();
        }

    TKeyArrayFix key( TSpdiaIndexDataVPbk::OffsetValue( TSpdiaIndexDataVPbk::EIndex ), ECmpTInt );
    iSdmArray->Sort( key );

    CFormattedCellListBoxData* list = aGrid->ItemDrawer()->FormattedCellData();
    if ( list->IconArray() == NULL )
        {
        aGrid->ItemDrawer()->FormattedCellData()->SetIconArrayL( iIconArray );
        }

    if ( thumbCount == 0 || State() != STATE_ASSIGN )
        {
        // fill number icon, avoid flicker
        array->Reset();
        SetItemDataL( *array );
        if ( thumbCount == 0 )
        	DrawNow();
        }
    return ETrue;

    }

// ---------------------------------------------------------
// CSpdiaContainer::SetLayout
//
// ---------------------------------------------------------
//
EXPORT_C void CSpeedDialPrivate::SetLayout(const TRect& aRect)
	{
	//Scalable UI.
	if(AknLayoutUtils::ScalableLayoutInterfaceAvailable() )
	{
	TRect			   	 mainPaneRect ;
    TRect 			   	 statusPaneRect;
    TAknLayoutRect     	 mainQdialRect;
	TAknLayoutRect     	 gridQdialPaneRect;
	TAknLayoutRect     	 cellQdialPaneRect;
    TAknWindowLineLayout cellQdialPane;
    TInt 				 varient =0;
			
	if (Layout_Meta_Data::IsLandscapeOrientation())
	{
	 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane,mainPaneRect);
	 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EStatusPane,statusPaneRect);
	 mainPaneRect.iTl = statusPaneRect.iTl;
	 mainPaneRect.iBr.iY = mainPaneRect.iBr.iY - statusPaneRect.iTl.iY;
	 varient =1;
	}
	else
	{
	 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane,mainPaneRect);
	 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EStatusPane,statusPaneRect);
	 mainPaneRect.iTl= statusPaneRect.iTl;
	}
		
	SetRect(mainPaneRect);
		
	mainQdialRect.LayoutRect(mainPaneRect,AknLayoutScalable_Apps::main_qdial_pane().LayoutLine());
	gridQdialPaneRect.LayoutRect(mainQdialRect.Rect(),AknLayoutScalable_Apps::grid_qdial_pane().LayoutLine());
	cellQdialPaneRect.LayoutRect(gridQdialPaneRect.Rect(),AknLayoutScalable_Apps::cell_qdial_pane(0,0).LayoutLine());
    cellQdialPane = AknLayoutScalable_Apps::cell_qdial_pane_g4(varient).LayoutLine();
			
	TInt Cnt = 0;
			
	for(TInt rowSize=0;rowSize < 3; rowSize++)
		{
			for(TInt column=0;column < 3; column++)
			{
				icellLayout[Cnt].LayoutRect(gridQdialPaneRect.Rect(),AknLayoutScalable_Apps::cell_qdial_pane(column,rowSize).LayoutLine());	
				Cnt ++ ;	
			}
				
		}
				

	 (*iShadowLayout)[CSpdiaGridVPbk::EtnCIF].LayoutRect(cellQdialPaneRect.Rect(),cellQdialPane);

	 (*iShadowLayout)[CSpdiaGridVPbk::EtnVGA90].LayoutRect(cellQdialPaneRect.Rect(),cellQdialPane);

	 (*iShadowLayout)[CSpdiaGridVPbk::EtnVGA].LayoutRect(cellQdialPaneRect.Rect(),cellQdialPane);

	 (*iShadowLayout)[CSpdiaGridVPbk::EtnCOM].LayoutRect(cellQdialPaneRect.Rect(),cellQdialPane);
	      
	            
	}
	else
	{
	TAknWindowLineLayout lScr = AknLayout::screen();
	TAknWindowLineLayout lCtrlPane = AknLayout::control_pane(TRect( TPoint(lScr.il, lScr.it), TSize(lScr.iW, lScr.iH) ));
	SetRect(TRect( TPoint(lScr.il, lScr.it), TSize(lScr.iW, lScr.iH - lCtrlPane.iH) ) );

    (*iShadowLayout)[CSpdiaGridVPbk::EtnCIF90].LayoutRect(aRect,AppLayout::Cell_pane_elements__qdial__Line_1());
    (*iShadowLayout)[CSpdiaGridVPbk::EtnCIF].LayoutRect(aRect,AppLayout::Cell_pane_elements__qdial__Line_4());
    (*iShadowLayout)[CSpdiaGridVPbk::EtnVGA90].LayoutRect(aRect,AppLayout::Cell_pane_elements__qdial__Line_7());
    (*iShadowLayout)[CSpdiaGridVPbk::EtnVGA].LayoutRect(aRect,AppLayout::Cell_pane_elements__qdial__Line_10());
    (*iShadowLayout)[CSpdiaGridVPbk::EtnCOM].LayoutRect(aRect,AppLayout::Cell_pane_elements__qdial__Line_13());
		}
    }


// ---------------------------------------------------------
// CSpeedDialPrivate::VMBoxPosition
//
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::VMBoxPosition() const
    {
    return KVoiceMail;
    }
    
// ---------------------------------------------------------
// CSpeedDialPrivate::VdoMBoxPosition
//
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::VdoMBoxPosition() const
    {
    if ( !iVmbxsupported )
        {
        // Video Mailbox feature is disabled
        return KErrNone;
        }
   
    if ( iVmbxkeypos )
        {
        return iVmbxkeypos - 1;
        }

    return KErrNone;
    }
//CSpeedDialPrivate::SpdIconIndex
// An interface for accessing index data array.
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::SpdIconIndex(TInt aIndex) const
    {
    return (*iSdmArray)[aIndex].IconIndex();
    }
    
    
// ---------------------------------------------------------
// CSpeedDialPrivate::DeleteIconArray
// Deletes the old icons.
// ---------------------------------------------------------
EXPORT_C void CSpeedDialPrivate::DeleteIconArray()
	{
	 if(iIconArray)
		 {
			iIconArray->ResetAndDestroy();
			delete iIconArray;
			iIconArray = NULL;
		 }
	}
	
// ---------------------------------------------------------
// CSpeedDialPrivate::ReloadIconArray
// Reloads the new skin icons.
// ---------------------------------------------------------
EXPORT_C void CSpeedDialPrivate::ReloadIconArray()
{
	TRAPD(err,
	{
		if (iGrid)
		{
			if(NULL == iIconArray)
			{
		    	iIconArray = new (ELeave)CAknIconArray(iSdmCount);
		    }
		
            if ( SetIconArrayL( iIconArray ) > 0 )
            {
            	SetOperationsL();
            }
        
            iGrid->ItemDrawer()->FormattedCellData()->SetIconArrayL( iIconArray );
		}
	});
	
	//Just to avoid warning..
	if(err)
	{
		
	}
}

// ---------------------------------------------------------
// CSpeedDialPrivate::SetIconArrayL
//
// ---------------------------------------------------------
TInt CSpeedDialPrivate::SetIconArrayL(CArrayPtrFlat<CGulIcon>* aArray)
    {
	CFbsBitmap* bitmap,*mask;
	bitmap = NULL;
	mask= NULL;
	MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();
 
    if ( aArray != NULL )
        {
        aArray->ResetAndDestroy();
        }
    else
        {
        return 0;
        }

	TInt existThumb(0);
    for (TInt index(0); index < iSdmArray->Count(); index++)
        {
		if(index == 0)
		{
		 TUid uidVmbx;
		 uidVmbx.iUid =KVmbxUid;
		 AknsUtils::CreateAppIconLC( skinInstance,uidVmbx, EAknsAppIconTypeContext,bitmap ,mask);		
		 CleanupStack::Pop(2);
		}
		else
		{
		 	if(User::Language() == ELangHindi)
		 	{
		 		AknsUtils::CreateIconL(skinInstance, (*iDialSkinBmp)[index],bitmap,mask,iBmpPath,iDialHindiBmp[index],  iDialHindiBmpMask[index] );	
		 	}
		 	else
		 	 {
		 	 	AknsUtils::CreateIconL(skinInstance, (*iDialSkinBmp)[index],bitmap,mask,iBmpPath,iDialBmp[index],  iDialBmpMask[index] );	
		 	 }
		}
		CGulIcon* icon = CGulIcon::NewL(bitmap,mask);
        CleanupStack::PushL(icon);
        aArray->AppendL(icon);

        if (CreateIndexIconL(index,
            (*iSdmArray)[index], existThumb > 0? EFalse: ETrue))
            {
            ++existThumb;
            }
        CleanupStack::Pop(); // icon
        }

		CreateFieldIconsL(aArray);

    return existThumb;
    }
	
	
// ---------------------------------------------------------
// CSpeedDialPrivate::VoiceMailTypeL	
//
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::VoiceMailType()
    {
    return iType;
    }
    
// ---------------------------------------------------------
// CSpeedDialPrivate::GetSpdCtrlLastError()
// retuns last error 
// ---------------------------------------------------------
//	
EXPORT_C TInt CSpeedDialPrivate::GetSpdCtrlLastError()
    {
     return iError;
 	}
	
// ---------------------------------------------------------
// CSpdiaContainer::Draw
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::Draw(const TRect& /*aRect*/) const
    {
    CWindowGc& gc = SystemGc();
   AknsDrawUtils::Background(
       AknsUtils::SkinInstance(),
       AknsDrawUtils::ControlContext(this),
       this,
       gc,
       Rect() );
    }
    
// ---------------------------------------------------------
// CSpeedDialPrivate::SizeChanged()
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::SizeChanged()
{
		iBgContext->SetRect( Rect() );
}

// ---------------------------------------------------------
// CSpeedDialPrivate::MopSupplyObject() 
// Pass skin information if need.
// ---------------------------------------------------------
//
TTypeUid::Ptr CSpeedDialPrivate::MopSupplyObject(TTypeUid aId)
{
    if(aId.iUid == MAknsControlContext::ETypeId)
    {
        return MAknsControlContext::SupplyMopObject( aId, iBgContext );
    }
    return CCoeControl::MopSupplyObject( aId );
}	
	
// ---------------------------------------------------------
// CSpeedDialPrivate::NumberType
// An interface for accessing phone number type.
// Number types are defined in PbkFields.hrh.
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::NumberType(TInt aIndex) const
{
	TInt retVal = ESpDialPbkFieldIdNone;
	TInt fieldId = -1;	
	MVPbkStoreContactField* field = (*iSdmArray)[aIndex].Field();
	
	if(field)
	{
		fieldId = field->BestMatchingFieldType()->FieldTypeResId();
		
		switch(fieldId)
		{
			case R_VPBK_FIELD_TYPE_VIDEONUMBERHOME:
			case R_VPBK_FIELD_TYPE_VIDEONUMBERWORK:
			case R_VPBK_FIELD_TYPE_VIDEONUMBERGEN:
				retVal = ESpDialPbkFieldIdPhoneNumberVideo;
				break;
			case R_VPBK_FIELD_TYPE_VOIPHOME:
			case R_VPBK_FIELD_TYPE_VOIPWORK:
			case R_VPBK_FIELD_TYPE_VOIPGEN:
			case R_VPBK_FIELD_TYPE_IMPP:
				retVal = ESpDialPbkFieldIdVOIP;
				break;
			default:
				retVal = ESpDialPbkFieldIdPhoneGeneral;
		}
	}
    return retVal;
}

// ---------------------------------------------------------
// CSpeedDialPrivate::DrawShadow
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::DrawShadow(CWindowGc& aGc) const
    {
    //TSize size(cell_spdia_item_w, cell_spdia_item_h);
	//Scalable UI.
	TAknWindowLineLayout area;
	if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )
	{
	 area = AknLayoutScalable_Apps::cell_qdial_pane(0,0).LayoutLine();           
	}
	else
	{
	 area = AppLayout::cell_qdial_pane(0,0);
	}
	
	TSize size(area.iW, area.iH);
    aGc.SetPenColor(AKN_LAF_COLOR(SDM_TN_SHADOW_COROL));
    TInt count(iSdmArray->Count());
	//TRect rect(TPoint(spdia_main_pane_grid_l, spdia_main_pane_grid_t), size);
	//Scalable UI
	if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )
	{
	 area = AknLayoutScalable_Apps::grid_qdial_pane().LayoutLine();
	}
	else
	{
	 area = AppLayout::Speed_Dial_descendants_Line_1();
	}
    TRect rect(TPoint(area.il, area.it), size);
    for (TInt i(0); i < count; ++i)
        {
        if (ThumbIndex(i) >= 0)
            {
            TInt type(ThumbType(i));
            TRect rc((*iShadowLayout)[type].Rect());
            if (type == CSpdiaGridVPbk::EtnCOM)
                {
                TSize image(ThumbSize(i));
                image.iWidth = Min(image.iWidth, rc.Width());
                image.iHeight = Min(image.iHeight, rc.Height());
                rc = TRect(TPoint(0,0), image);
                // Correct the x and y to the accurate values.
                TInt x(Max(0, (size.iWidth - image.iWidth) / 2) + 3);
                TInt y(Max(0, (size.iHeight - image.iHeight) / 2) - 2);
                rc.Move(x, y);
                }
            rc.Move(rect.iTl.iX, rect.iTl.iY);
            aGc.DrawRect(rc);
            }
        rect.Move(size.iWidth, 0);
        if (((i + 1)/ KCellColCount) * KCellRowCount == i + 1)
            {
            rect.Move(-(KCellColCount * size.iWidth), size.iHeight);
            }
        }
    }

// ---------------------------------------------------------
// CSpeedDialPrivate::CheckingIfPopUpNeededL
// Internal rutine to check if pop up has to be shown		
// to enable the One-Key-Dialling setting.
// ---------------------------------------------------------
//

EXPORT_C TBool CSpeedDialPrivate::CheckingIfPopUpNeededL()
    {
    TBool gridEmpty( ETrue );
    TInt  gridIndex( 1 );
    TInt value;
    TBool result( ETrue );

    CRepository* repository = CRepository::NewL( KCRUidTelephonySettings );
    repository->Get( KSettingsOneKeyDialling, value );

    if ( value == 0 )
        {
        while ( ( gridIndex < 9 ) && gridEmpty )
            {
            if ( ( *iSdmArray )[ gridIndex ].Contact() != NULL )
                {
                gridEmpty = EFalse;
                }
            ++gridIndex;
            }
        result = gridEmpty;	
        }
    else
        {
        result = EFalse;
        }
    delete repository;
    return result;
    }
		
// ---------------------------------------------------------
// CSpeedDialPrivate::Pbk2ImageGetComplete
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::Pbk2ImageGetComplete
        (MPbk2ImageOperation& aOperation, CFbsBitmap* aBitmap)
 {
	TRAP_IGNORE(Pbk2ImageGetCompleteL(aOperation, aBitmap));
 }
 
// ---------------------------------------------------------
// CSpeedDialPrivate::Pbk2ImageGetCompleteL
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::Pbk2ImageGetCompleteL
        (MPbk2ImageOperation& aOperation, CFbsBitmap* aBitmap)
 {
 	
    //for async call	 
    TInt index(HasImageOperation(aOperation));
    
    if (index != KNullIndexData)
    {
		if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )
			{
			CAknIcon* icon = CAknIcon::NewL();
			icon->SetBitmap(aBitmap);

			// create mask
			CFbsBitmap* mask = new (ELeave) CFbsBitmap();

			TSize size = aBitmap->SizeInPixels();
			mask->Create(size,EGray2);

			CFbsBitGc* fbsBitGc = CFbsBitGc::NewL();
			CleanupStack::PushL( fbsBitGc );
			CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL( mask );
			CleanupStack::PushL( bmpDevice );
			bmpDevice->Resize( size );
			fbsBitGc->Activate( bmpDevice );

			fbsBitGc->SetPenStyle(CGraphicsContext::ENullPen);
			fbsBitGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

			fbsBitGc->SetBrushColor(KRgbBlack); 
			fbsBitGc->DrawRect( TRect( size ) );

			CleanupStack::PopAndDestroy( 2, fbsBitGc ); // bmpDevice and fbsBitGc

			icon->SetMask(mask);

			// this creates both scalable icon and mask
			CAknIcon* scaledIcon = AknIconUtils::CreateIconL(icon);

			TSize thumbnailSize = GetThumbnailSize();

			AknIconUtils::SetSize(scaledIcon->Bitmap(),thumbnailSize,EAspectRatioPreservedAndUnusedSpaceRemoved);
			AknIconUtils::SetSize(scaledIcon->Mask(),thumbnailSize,EAspectRatioPreservedAndUnusedSpaceRemoved);

			CFbsBitmap* bmp = new (ELeave) CFbsBitmap();
			CFbsBitmap* msk = new (ELeave) CFbsBitmap();
			TInt err = msk->Duplicate( scaledIcon->Mask()->Handle() ); 
			TInt err1 = bmp->Duplicate( scaledIcon->Bitmap()->Handle() );			

            delete ( *iIconArray )[index];
            ( *iIconArray )[index] = NULL;
            ( *iIconArray )[index] = CGulIcon::NewL( bmp, msk );
            // set the text array of grid
            ( *iSdmArray )[index].SetThumbIndex( index, bmp );
            delete scaledIcon;
            }       
            
        else
            {
            // set the scaled bitmap to the array of icons
            delete ( *iIconArray )[index];
            ( *iIconArray )[index] = NULL;
            ( *iIconArray )[index] = CGulIcon::NewL( aBitmap );
            // set the text array of grid
            ( *iSdmArray )[index].SetThumbIndex( index, aBitmap );
             }

	       if ( ( *iSdmArray )[index].LastThumb() )
	            {
	            CDesCArray* array = STATIC_CAST( CDesCArray*, iGrid->Model()->ItemTextArray() );
	            array->Reset();
	            SetItemDataL( *array );
	            DrawNow();
	            }
	        delete &aOperation;
	        ( *iSdmArray )[index].SetImageOperation( NULL ); 
	    }
	
    iOperationComplete = ETrue;
    Release();
	}

	
// ---------------------------------------------------------
// CSpeedDialPrivate::Pbk2ImageGetFailed
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::Pbk2ImageGetFailed
        ( MPbk2ImageOperation& aOperation,
        TInt aError )
    {
    iError = aError;
    TInt index( HasImageOperation( aOperation ) );
    if ( index != KNullIndexData )
        {
        delete &aOperation;
        ( *iSdmArray )[index].SetImageOperation( NULL );
        if ( ( *iSdmArray )[index].LastThumb() )
            {
            CDesCArray* array = STATIC_CAST( CDesCArray*, iGrid->Model()->ItemTextArray() );
            array->Reset();
            TRAP_IGNORE( SetItemDataL( *array ) );
            DrawNow();
            }
        }
    iOperationComplete = ETrue;
    Release();
    }


// ---------------------------------------------------------
// CSpeedDialPrivate::HasImageOperation
//
// ---------------------------------------------------------
//
TInt CSpeedDialPrivate::HasImageOperation(MPbk2ImageOperation& aOperation)
{
	TInt index = KNullIndexData;
	for(TInt count =0; count < iSdmArray->Count() && index == KNullIndexData; ++count)
	{
	    if ((*iSdmArray)[count].ImageOperation() == &aOperation)
        {
             index = count;
        }		
	}
	return index;
}

// ---------------------------------------------------------
// CSpeedDialPrivate::SetDetails
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::SetDetails(TInt aIndex)
{
	MVPbkStoreContactField* field = (*iSdmArray)[aIndex].Field();
	
	if(field != NULL)
	{
    HBufC* number = NULL;
    TRAP_IGNORE(
            {
            TVPbkFieldStorageType dataType = field->FieldData().DataType();
            
            switch( dataType )
                {
                case EVPbkFieldStorageTypeText:
                    {
                    const MVPbkContactFieldTextData& data = MVPbkContactFieldTextData::Cast( field->FieldData() );
                    number = data.Text().AllocLC();
                    break;
                    }
                case EVPbkFieldStorageTypeUri:
                    {
                    const MVPbkContactFieldUriData& data = MVPbkContactFieldUriData::Cast( field->FieldData() );
                    number = data.Text().AllocLC();
                    break;
                    }
                }
        
            if (number != NULL)
				{
				//store the phone numbers in a array and cast those to TPhCltTelephoneNumber.
            	(*iSdmArray)[aIndex].SetPhoneNumber(*number);		           
            	CleanupStack::PopAndDestroy( number );
				}
			
			//Push
            const MVPbkFieldType* fieldType = field->BestMatchingFieldType();
            TInt iconindex = FindIconIndex(fieldType->FieldTypeResId());
            (*iSdmArray)[aIndex].SetIconIndex(iconindex);
    
            //No need to fetch thumbnail now...will be updated while grid is
            // drawn
            (*iSdmArray)[aIndex].SetThumbIndex(-1,NULL);	
            }
        );	
	}
	    
}
// ---------------------------------------------------------
// CSpeedDialPrivate::AttributeOperationComplete
//
// ---------------------------------------------------------
//

void CSpeedDialPrivate::AttributeOperationComplete( MVPbkContactOperationBase& aOperation)
{

    TInt index = HasOperation(&aOperation);
     
     //for async call
    if (index != KNullIndexData)
    {
        TSpdiaIndexDataVPbk::TOperation operation = (*iSdmArray)[index].Operation();    
        //MVPbkStoreContactField* field = (*iSdmArray)[index].Field();
        
        switch(operation)
        {
            case TSpdiaIndexDataVPbk::OPERATION_ASSIGN:
            
                TRAPD(err,
                {
                                
                HBufC* prompt = StringLoader::LoadLC(R_SPDIA_TEXT_KEY_ASSIGNED, index+1, iCoeEnv);
                CAknConfirmationNote* note = new (ELeave)CAknConfirmationNote();
                note->ExecuteLD(*prompt);
                
                CleanupStack::PopAndDestroy(prompt);
                });
                if(err == KErrNone)
                {
                    SetDetails(index);
                }
            
            break;
            
            case TSpdiaIndexDataVPbk::OPERATION_REMOVE:
                (*iSdmArray)[index].Reset();                
            
            break;
            
            case TSpdiaIndexDataVPbk::OPERATION_NONE:
            
            //Error Handling
            
            break;
                    
            
        }
        
        iOperationComplete = ETrue;
        Release();
            
    }
    
  //  CleanupStack::PopAndDestroy();     
}

// ---------------------------------------------------------
// CSpeedDialPrivate::AttributeOperationFailed
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::AttributeOperationFailed(MVPbkContactOperationBase& aOperation, TInt aError) 
{
	
	TInt index(HasOperation(&aOperation));
	
	if (index != KNullIndexData)
	{
		TSpdiaIndexDataVPbk::TOperation operation = (*iSdmArray)[index].Operation();	
		
		switch(operation)
		{
			case TSpdiaIndexDataVPbk::OPERATION_ASSIGN:
				(*iSdmArray)[index].Reset();
			break;
			
			case TSpdiaIndexDataVPbk::OPERATION_REMOVE:
				(*iSdmArray)[index].Reset();
			break;
			
			default:
			 	delete &aOperation;
		}
		iError = aError;
		iOperationComplete = ETrue;
		Release();
		
	}
			

}


// ---------------------------------------------------------
// CSpeedDialPrivate::HasOperation
//
// ---------------------------------------------------------
//
TInt CSpeedDialPrivate::HasOperation(MVPbkContactOperationBase* aContactOpertion)
{
	TInt i=0, index = KNullIndexData;		
	for(i=0;i<iSdmArray->Count() && index == KNullIndexData;++i)
	{
		if ((*iSdmArray)[i].HasOperation(aContactOpertion))
		{
			index =i;
		}
	}
	
	return index;
}


// ---------------------------------------------------------
// CSpeedDialPrivate::EMail
//
// ---------------------------------------------------------
//
EXPORT_C HBufC* CSpeedDialPrivate::EMail( MVPbkStoreContact* aContact )
    {  

        TUint fetchFlags = 0;
        iMail = NULL;
        iFetchmail = ETrue;
        // Set service data
        TAiwSingleItemSelectionDataV3 data;

        data.SetFlags(fetchFlags);
        data.SetCommAddressSelectType(EAiwCommEmailEditor);
        TRAP_IGNORE(
                {
        CAiwGenericParamList& inParamList = iServiceHandler->InParamListL();
        inParamList.AppendL(TAiwGenericParam(EGenericParamContactSelectionData,
          TAiwVariant(TAiwSingleItemSelectionDataV3Pckg(data))));

        MVPbkContactLinkArray* linkArray = NULL;
        CVPbkContactLinkArray* array = CVPbkContactLinkArray::NewLC();
        MVPbkContactLink* ContactLink = aContact->CreateLinkLC();
        CleanupStack::Pop();
        array->AppendL(ContactLink);
        linkArray = array;
      
        HBufC8* PackLink = linkArray->PackLC();
        inParamList.AppendL(TAiwGenericParam(EGenericParamContactLinkArray,
          TAiwVariant(*PackLink)));
        CleanupStack::PopAndDestroy();//PackLink
        CleanupStack::PopAndDestroy();//linkArray
        CAiwGenericParamList& outParamList = iServiceHandler->OutParamListL();
        iServiceHandler->ExecuteServiceCmdL(KAiwCmdSelect, inParamList,
                outParamList, 0, this);
                }
                    );
        iOperationComplete = EFalse;
        // Wait till the contact is selected
        while ( !iOperationComplete )
        {
            Wait();
        }
        iFetchmail = EFalse;
        return iMail;
    }

// ---------------------------------------------------------
// CSpeedDialPrivate::SetSpeedDialIndexL
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::SetSpeedDialIndexL(MVPbkStoreContact* aContact)
{
	TInt count =0;
	TInt index = KNullIndexData;
	
	//	Do a linear search to find which is the speeddial index 
	// 	stored in this field.
	for(count =0; count<KArraySize && index ==KNullIndexData; ++count)
	{
		// Compare with every speeddial attribute
		iSpeedDial->SetIndex(count+1);
		
		//If the index is not assigned already..
		if((*iSdmArray)[count].Contact() == NULL)
		{
			MVPbkStoreContactFieldCollection* fieldCollection = iAttributeManager->FindFieldsWithAttributeLC(
                						*(iSpeedDial), *aContact); 
			if(fieldCollection && (fieldCollection->FieldCount() > 0))
			{
				index = count;
				
				MVPbkStoreContactField& field = fieldCollection->FieldAt(0);
				
				(*iSdmArray)[index].SetContactLink(field.CreateLinkLC());
				(*iSdmArray)[index].SetContact(aContact);
				CleanupStack::Pop();
				
	            TVPbkFieldStorageType dataType = field.FieldData().DataType();
	            HBufC* number = NULL;
	            switch( dataType )
                {
	                case EVPbkFieldStorageTypeText:
                    {
	                    const MVPbkContactFieldTextData& data = MVPbkContactFieldTextData::Cast( field.FieldData() );
	                    number = data.Text().AllocLC();
	                    break;
                    }
	                case EVPbkFieldStorageTypeUri:
                    {
	                    const MVPbkContactFieldUriData& data = MVPbkContactFieldUriData::Cast( field.FieldData() );
	                    number = data.Text().AllocLC();
	                    break;
                    }
                }
				
			    if ( number != NULL )
                {
					TPhCltTelephoneNumber phonenumber(*number);
                    phonenumber.Trim();
					CleanupStack::PopAndDestroy( number );
					//store the phone numbers in a array and cast those to TPhCltTelephoneNumber.
                    if(phonenumber.Length() > 0)
                    {
                        (*iSdmArray)[index].SetPhoneNumber(phonenumber);
                    }
                }
                else
                {
                    //Remove SpeedDial
                }
			}
			
			CleanupStack::PopAndDestroy(); // Pop and Destroy FieldCollection
			
		}
	}
	//Delete if we are not using that contact..
	if(KNullIndexData == index)
	{
		delete aContact;
	}
	
}
	
// ---------------------------------------------------------
// CSpeedDialPrivate::VPbkSingleContactOperationComplete()
//
// ---------------------------------------------------------
void CSpeedDialPrivate::VPbkSingleContactOperationComplete( MVPbkContactOperationBase& aOperation, 
													MVPbkStoreContact* aContact)
{

 	if (iState == STATE_INITIAL)
 	{
 		TRAP_IGNORE(SetSpeedDialIndexL(aContact));
 		iRetrieveComplete = ETrue;
		Release();
 	}
 	else if(iState == STATE_CONTACTCHANGE)
 	{
 		iContact = aContact;
 		iRetrieveComplete = ETrue;
		Release();
 	}
 	else
 	{
		
		TInt index = HasOperation(&aOperation);
		
		if (index != KNullIndexData)
		{
			TSpdiaIndexDataVPbk::TOperation operation = (*iSdmArray)[index].Operation();
			if(TSpdiaIndexDataVPbk::OPERATION_ASSIGN == operation)
			{	
				
				// Store the contact and field in corresponding index
				(*iSdmArray)[index].SetContact(aContact);
				(*iSdmArray)[index].SetContactLink(iContactLink);
				iRetrieveComplete = ETrue;
				Release();
						
			}
			else if(TSpdiaIndexDataVPbk::OPERATION_ASSIGN_CONTACT == operation)
			{
          iSpeedDial->SetIndex(index + 1);
          TRAP_IGNORE(
              {
              MVPbkStoreContactFieldCollection* fieldCollection = iAttributeManager->FindFieldsWithAttributeLC( *( iSpeedDial ), *aContact ); 
              if ( fieldCollection && ( fieldCollection->FieldCount() > 0 ) )
                  {
                  // update speeddial information
                  MVPbkStoreContactField& field = fieldCollection->FieldAt( 0 );
                  ( *iSdmArray )[ index ].SetContactLink( field.CreateLinkLC() );
                  ( *iSdmArray )[ index ].SetContact( aContact );
                  CleanupStack::Pop();
                  SetDetails( index );
                  }

          		CleanupStack::PopAndDestroy(); // Pop and Destroy FieldCollection
              }
          )				
				  iRetrieveComplete = ETrue;
				  Release();
			}
		 	//delete &aOperation;
		}
 	}
}

// ---------------------------------------------------------
// CSpeedDialPrivate::VPbkSingleContactOperationFailed()
//
// ---------------------------------------------------------
void CSpeedDialPrivate::VPbkSingleContactOperationFailed(
                 MVPbkContactOperationBase& /*aOperation*/, 
                 TInt aError)
{
	iError = aError;
	iRetrieveComplete = ETrue;
	Release();

}
                 
// ---------------------------------------------------------
// CSpeedDialPrivate::ShowAssignL()
//
// ---------------------------------------------------------
TBool CSpeedDialPrivate::ShowAssignL( MVPbkContactLink& aContactLink, TInt& aIndex )
{
	TBool aReturn (EFalse);
	
    TRAPD(err,iGridDlg = CSpdiaGridDlgVPbk::NewL(aIndex, *this));
    
    // Execute the CPbkFetchEntryDlg dialog
    TInt result(ETrue);
    
	if(err == KErrNone)
	{
	    TRAPD(error, result = iGridDlg->ExecuteLD(R_SPDIA_GRID_DIALOG));
    	iGridDlg = NULL; 
    	iIconArray = NULL;	
    	 // Check errors
    	User::LeaveIfError(error);
	}

  
   
   	TBool popUp = ETrue;
   	
    if (iBooleanVarForAddingDialogVariation)
	{
		if(!CheckingIfPopUpNeededL())
		  popUp = EFalse;
	}
   	if (popUp && result && !CheckSpaceBelowCriticalLevelL())
   	{
	//for contact link
  	TUint assignFlags = 0; 
    ExecuteSingleEntryAssignL(aIndex-1,AiwContactAssign:: TAiwContactAttributeAssignDataV1().SetFlags(assignFlags));//amit
    aReturn = ETrue;
    //return aReturn;
    // for contact link
		   	    	    
		if((*iSdmArray)[aIndex-1].Contact() != NULL)
		{
			result = RemoveSpeedDialL(aIndex-1);
		}
		
		//If removal was successful
		if(result != EFalse)
		{
		   	iRetrieveComplete = EFalse;
		   	if(iContactLink)
		   	{
		   		delete iContactLink;
		   		iContactLink= NULL;
		   	}
		 	iContactLink = aContactLink.CloneLC();
		 	CleanupStack::Pop();
		 	
	    MVPbkContactOperationBase* operation = iContactManager->RetrieveContactL( aContactLink, (*this ));
		   		      
		    if(operation)
		    {
				(*iSdmArray)[aIndex-1].SetOperation(operation,TSpdiaIndexDataVPbk::OPERATION_ASSIGN);
				
				while (!iRetrieveComplete)
			    {
			    	Wait();
			    }
			    //If retrieval is successful
				if(iError == KErrNone)
				{
					AssignSpeedDialL(aIndex-1);				
					aReturn = ETrue;
				}
				else
				{
					delete iContactLink;
				}
			   	
		    }
		}
	    
	    iContactLink = NULL;
   	}

	return aReturn;	   	
}

// ---------------------------------------------------------
// CSpeedDialPrivate::ShowAssignL()
//
// ---------------------------------------------------------
TBool CSpeedDialPrivate::ShowAssignL( TInt aIndex, MVPbkContactLink*& aContactLink  )
    {

    // Have to display the title of SpeedDial when called 
    // from SpeedDial application...May be that function can be moved to
    // speed dial application...

    TBool result = ETrue;
    HBufC* prompt = NULL;
    TBuf<KOperatorNameLength> operatorName;
    
    aIndex = aIndex-1;
    if (iBooleanVarForAddingDialogVariation )
        {
        if(iPopupDialog)
            {
            if(!CheckingIfPopUpNeededL())
            result = EFalse;
            }
        }

    if ( !CheckSpaceBelowCriticalLevelL() )
        {
        if ( iGridUsed == EGridNoUse && (*iSdmArray)[aIndex].Contact() == NULL )
            {
            iQueryDialog = CAknQueryDialog::NewL(CAknQueryDialog::ENoTone);
            TBool resDialog(EFalse);
            TRAPD(error,
            resDialog = iQueryDialog->ExecuteLD(R_SPDIA_QUERY_ASSIGN) );
            iQueryDialog = NULL;
            User::LeaveIfError(error);
            if (!resDialog)
                {
                result = EFalse;
                } 
            }

        if ( result && (*iSdmArray)[aIndex].Contact() != NULL )
            {
            //if(iGridUsed == EGridNoUse)//because grid will be used if you want to replace or change
            if ( iGridUsed == EGridUse )
                {
                MakeVisible( ETrue );
                result = ETrue;
                MakeVisible( EFalse );
                }
            }

        if(result)
            {
            TUint assignFlags = 0;            
            //assignFlags |= (AiwContactAssign::EUseProviderTitle);//|AiwContactAssign::EDoNotOpenEditor); 
            CAknTitlePane* title = NULL;
            CEikStatusPane *sp = CEikonEnv::Static()->AppUiFactory()->StatusPane();
            title =  STATIC_CAST(CAknTitlePane*, sp->ControlL( TUid::Uid(EEikStatusPaneUidTitle) ) );
            prompt = StringLoader::LoadLC(R_QTN_SPDIA_TITLE, iCoeEnv);
            operatorName.Copy(*title->Text());
            title->SetTextL(*prompt);
            title->MakeVisible(ETrue);
            CleanupStack::PopAndDestroy(prompt); 
            
            ExecuteSingleEntryAssignL(aIndex,AiwContactAssign:: TAiwContactAttributeAssignDataV1().SetFlags(assignFlags));

            if ( iCancelFlag )
                {
                iCancelFlag = EFalse;
                return result;
                }

            if ( iError == KErrNone && iContactLink != NULL )
                {
                (*iSdmArray)[aIndex].Reset();
                //Retrieve Contact and assign fields to the index..
                iRetrieveComplete = EFalse;
                MVPbkContactOperationBase* operation = iContactManager->RetrieveContactL( *iContactLink, (*this ));

                if(operation)
                    {
                    (*iSdmArray)[aIndex].SetOperation(operation,TSpdiaIndexDataVPbk::OPERATION_ASSIGN_CONTACT);

                    while (!iRetrieveComplete)
                        {
                        Wait();
                        }
                    if ( iError == KErrNone )
                        {
                        result = ETrue;	
                        }
                    else
                        {
                        //We are taking a copy of contact links..
                        //If we can't store it, delete the link..
                        delete iContactLink;
                        iContactLink = NULL;
                        result = EFalse;
                        }
                    }
                }

            else if( iError == KErrInUse )
                {
                ShowNoteL( R_QTN_SPDIA_CONTACT_IN_USE );
                }

            if(iContactLink != NULL)
                {
                aContactLink = iContactLink->CloneLC();
                CleanupStack::Pop();	    		
                delete iContactLink;
                }
            else
                {
                aContactLink = CONST_CAST(MVPbkContactLink*, iContactLink);
                }
            iContactLink = NULL;

            title->SetTextL( operatorName );
            } 
        }

        return result;

    }

// ---------------------------------------------------------
// CSpeedDialPrivate::ShowRemoveL
//
// ---------------------------------------------------------
//
TBool CSpeedDialPrivate::ShowRemoveL( TInt aIndex )
{

	TBool aReturn = EFalse;
		
	if ( (*iSdmArray)[aIndex].Contact()!= NULL )
	{
		iState = STATE_REMOVE;
		if((*iSdmArray)[aIndex].Field() != NULL)
		{
			iOperationComplete = EFalse;
			iSpeedDial->SetIndex(aIndex+1);
			(*iSdmArray)[aIndex].Contact()->LockL(*(this));

			while(!iOperationComplete)
			{
				Wait();
			}

			if(iError == KErrNone)
			{
				
				MVPbkStoreContactField* field = (*iSdmArray)[aIndex].Field();
				TPtrC label = field->FieldLabel();
				iOperationComplete = EFalse;
				MVPbkContactOperationBase* operation = NULL; 
				operation = iAttributeManager->RemoveFieldAttributeL(
														*field, *iSpeedDial, (*this));
				if(operation)
				{
					(*iSdmArray)[aIndex].SetOperation(operation,TSpdiaIndexDataVPbk::OPERATION_REMOVE);
				
					while(!iOperationComplete)
					{
						Wait();
					}

				}
				
				//If there are no errors
				if(iError == KErrNone)
				{
					aReturn = ETrue;
				}
			}
            else if( iError == KErrInUse )
                {
                // Prompt information note when contact is in use
                ShowNoteL( R_QTN_SPDIA_CONTACT_IN_USE );
                }
		}
	}
	
	return aReturn;
}

// ---------------------------------------------------------
// CSpeedDialPrivate::ShowAssign
// Function called when assigning speed dial from phone book
// application
// ---------------------------------------------------------
//
EXPORT_C TInt CSpeedDialPrivate::ShowAssign( MVPbkContactLink& aContactLink, TInt& aIndex )
   	{
   	iError = KErrNone;
   	iCurrentIndex = aIndex - 1;

   	TRAPD( err, ShowAssignL( aContactLink, aIndex ) );

   	if ( err )
   	   	{
   	   	iError = err;
   	   	}

   	iCurrentIndex = -1;
   	return iError;	
   	}
	
// ---------------------------------------------------------
// CSpdiaContainer::ShowAssignL
// Function called when assigning speed dial from SpeedDial and Telephony
// application
// ---------------------------------------------------------
//
	
EXPORT_C TInt CSpeedDialPrivate::ShowAssign( TInt aIndex, MVPbkContactLink*& aContactLink  )
   	{
   	iError = KErrNone;
   	if ( !iShowAssignCalled )
   	   	{
   	   	iShowAssignCalled = ETrue;
   	   	iCurrentIndex = aIndex - 1;

   	   	TRAPD( err, ShowAssignL( aIndex, aContactLink ) );

   	   	if ( err )
   	   	   	{
   	   	   	iError = err;
   	   	   	}
   	   	iCurrentIndex = -1;
   	   	iShowAssignCalled = EFalse;
   	   	} 	

   	return iError;
   	}

EXPORT_C TInt CSpeedDialPrivate::ShowRemove( TInt aIndex )
   	{
   	iError = KErrNone;

   	iCurrentIndex = aIndex;
   	TInt reValue = ETrue;
   	TRAP_IGNORE( reValue = ShowRemoveL( aIndex ) );

   	iCurrentIndex = -1;
   	return reValue;
   	}

    
// --------------------------------------------------------------------------
// CSpeedDialPrivate::StoreReady
//
// --------------------------------------------------------------------------
//
void CSpeedDialPrivate::StoreReady(MVPbkContactStore& /*aContactStore*/)
    {
    	iOperationComplete = ETrue;
    	Release();
    }
    
// --------------------------------------------------------------------------
// CSpeedDialPrivate::StoreUnavailable
//
// --------------------------------------------------------------------------
//
void CSpeedDialPrivate::StoreUnavailable
        (MVPbkContactStore& /*aContactStore*/, TInt /*aReason*/)
    {
    	iOperationComplete = ETrue;
    	Release();

    	//iError = aReason;
    }

// --------------------------------------------------------------------------
// CSpeedDialPrivate::SetState
//
// --------------------------------------------------------------------------
//    
EXPORT_C void CSpeedDialPrivate::SetState(eSpeedDialState aState)
{
	iState = aState;
}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::State
//
// --------------------------------------------------------------------------
// 
EXPORT_C  CSpeedDialPrivate::eSpeedDialState CSpeedDialPrivate::State()
{
	return iState;
}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::GridStatus
//
// --------------------------------------------------------------------------
// 
EXPORT_C  CSpeedDialPrivate::TGridUse CSpeedDialPrivate::GridStatus()
{
	return iGridUsed;
}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::SetGridStatus
//
// --------------------------------------------------------------------------
// 
EXPORT_C  void CSpeedDialPrivate::SetGridStatus(TGridUse aStatus)
{
	iGridUsed = aStatus;
}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::HandleStoreEventL
//
// --------------------------------------------------------------------------
//
void CSpeedDialPrivate::HandleStoreEventL(
        MVPbkContactStore& aContactStore,
        TVPbkContactStoreEvent aStoreEvent)
	{
	
	MVPbkContactStore* storeInList = iContactManager->ContactStoresL().Find(aContactStore.StoreProperties().Uri());
	
	if (storeInList !=NULL)
	{
	switch(aStoreEvent.iEventType)
		{
		
		case TVPbkContactStoreEvent::EContactChanged:
		case TVPbkContactStoreEvent::EContactDeleted:
		
		if ( iState == STATE_IDLE /*&& iUpdateFlag == EFalse*/ )
			{
			
			TInt findResult = 0;
			findResult = FindInSpeedDialContacts(aStoreEvent.iContactLink);
			
			if(findResult != EFalse)
				{
				if (iGridUsed != EGridUse)
					{
					if ( iRemoveConfirmQueryDialog 
						&& aStoreEvent.iEventType == TVPbkContactStoreEvent:: EContactChanged
						&& iCurrentIndex == findResult )
						{
						delete iRemoveConfirmQueryDialog;
						iRemoveConfirmQueryDialog = NULL;
						}
					iUpdateFlag = ETrue;
					// if CSpeedDialPrivate object is constructed by dialer, the value of iGrid is NULL
					if ( iGrid )
						{
						CreateDataL( *iGrid  );
						}
					// If the view number note popped up and the customer delete the image of contact
					// refresh the note dialog.
					if ( iRefreshObserver && iCurrentIndex == findResult )
						{
						iRefreshObserver->RefreshDialog();
						iUpdateFlag = ETrue;
						}
					}
				}
			else
				{
				if(CheckContactAssignedFromPhoneBookL(aStoreEvent.iContactLink))
					{
					if (iGridUsed != EGridUse)
						{
						iUpdateFlag = ETrue;
						// if CSpeedDialPrivate object is constructed by dialer, the value of iGrid is NULL
						if ( iGrid )
							{
							CreateDataL( *iGrid  );
							}
						}
					}
				
				}
			}	
		break;
		
		default:
		break;
		}
	
	}
	
	}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::SetUpdateFlag
//
// --------------------------------------------------------------------------
//
EXPORT_C void CSpeedDialPrivate::SetUpdateFlag(TBool aFlag)
{
	iUpdateFlag = aFlag;
}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::UpdateFlag
//
// --------------------------------------------------------------------------
//

EXPORT_C TBool CSpeedDialPrivate::UpdateFlag()
{
	return iUpdateFlag;
}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::FindInSpeedDialContacts
//
// --------------------------------------------------------------------------
//
    
TInt CSpeedDialPrivate::FindInSpeedDialContacts(MVPbkContactLink* aContactLink)    
    {
    // TBool found = EFalse;
    TInt found = 0;
    MVPbkStoreContact* contact = NULL;
    for ( TInt count = 0; count < iSdmArray->Count() && found != iCurrentIndex; ++count )
        {
        contact = ( *iSdmArray )[count].Contact();
        
        if ( contact != NULL && aContactLink->RefersTo( *contact ) )
            {
            found = iSdmArray->Count();
            // if the changed contact is the one which is focused in Speeddial,
            // then the note can be removed
            if ( count == iCurrentIndex )
                {
                found = iCurrentIndex;
                }
            }
        }
    return found;
    }

// --------------------------------------------------------------------------
// CSpeedDialPrivate::CheckContactAssignedFromPhoneBookL
//
// --------------------------------------------------------------------------
//
TBool CSpeedDialPrivate::CheckContactAssignedFromPhoneBookL(MVPbkContactLink* aContactLink)
{
	TBool aReturn = EFalse;
	iRetrieveComplete = EFalse;
	MVPbkContactOperationBase* operation = iContactManager->RetrieveContactL( *aContactLink,
											(*this ));
	//Save the old state																
	eSpeedDialState oldState = iState;
	
	iState = STATE_CONTACTCHANGE;
	if(operation != NULL)
	{
		while(!iRetrieveComplete)
		{
			Wait();
		}
		
		delete operation;
		if(iContact != NULL)
		{
			aReturn = iAttributeManager->HasContactAttributeL(
										CVPbkSpeedDialAttribute::Uid(),*iContact);
			delete iContact;
			iContact = NULL;
		}	
	}

	//Restore the old state
	iState  = oldState;
	return aReturn;
	
}


// --------------------------------------------------------------------------
// CSpeedDialPrivate::ExecuteSingleEntryAssignL
//
// --------------------------------------------------------------------------
//
void CSpeedDialPrivate::ExecuteSingleEntryAssignL(TInt aIndex,
        AiwContactAssign::TAiwContactAttributeAssignDataV1 aData)
    { 
    iState = STATE_ASSIGN;
        
    CAiwGenericParamList& inParamList = iServiceHandler->InParamListL(); 
    
    const TAiwVariant speedDialVariant( aIndex + 1 );
    /*
    TGenericParamId genericParam =
        TGenericParamId( EGenericParamSpeedDialIndex );*/
	//For the time being..phone book ui lib is compiled with this value...     
    TGenericParamId genericParam =
        TGenericParamId( EGenericParamSpeedDialIndex );
  
    inParamList.AppendL(TAiwGenericParam(
                    genericParam,
                    speedDialVariant
                    ) );  
  
    inParamList.AppendL( TAiwGenericParam( EGenericParamContactAssignData,
            TAiwVariant( AiwContactAssign::TAiwContactAttributeAssignDataV1Pckg( aData ) ) ) );
                                     

	iOperationComplete = EFalse;
	iContactLink = NULL;
    iServiceHandler->ExecuteServiceCmdL(
            KAiwCmdAssign, 
            inParamList, 
            iServiceHandler->OutParamListL(),
            0,
            this );                
    
    // Wait till the contact is selected
    while ( !iOperationComplete )
        {
        Wait();
        }
    
    // CleanupStack::PopAndDestroy();
    //iServiceHandler = NULL;
    }

// --------------------------------------------------------------------------
// CSpeedDialPrivate::ExecuteSingleEntryFetchL
//
// --------------------------------------------------------------------------
//
void CSpeedDialPrivate::ExecuteSingleEntryFetchL(TInt aIndex,
        TAiwSingleEntrySelectionDataV2 aData,
        const TDesC& aUri1)
{ 
    CAiwServiceHandler* serviceHandler = CAiwServiceHandler::NewL();
    
    serviceHandler->AttachL(R_SPDIA_SINGLE_ENTRY_FETCH_INTEREST);
    
    CleanupStack::PushL(serviceHandler);  
        
    CAiwGenericParamList& inParamList = serviceHandler->InParamListL();    
    inParamList.AppendL(
        TAiwGenericParam(
            EGenericParamContactSelectionData,
            TAiwVariant(TAiwSingleEntrySelectionDataV2Pckg(aData))));

    CVPbkContactStoreUriArray* uriArray = CVPbkContactStoreUriArray::NewL();
    CleanupStack::PushL(uriArray);
    if (aUri1.Length() > 0) 
	    {
	    uriArray->AppendL(aUri1);
			}  

    HBufC8* packedUris = uriArray->PackLC();
    if (uriArray->Count() > 0)
        {
        inParamList.AppendL(
        TAiwGenericParam(
                EGenericParamContactStoreUriArray,
                TAiwVariant(*packedUris)));
        }

	iOperationComplete = EFalse;
	iContactLink = NULL;
    serviceHandler->ExecuteServiceCmdL(
            KAiwCmdSelect, 
            inParamList, 
            serviceHandler->OutParamListL(),
            0,
            this);                
    CleanupStack::PopAndDestroy(2); // packedUris, uriArray, service handler
    
    //Wait till the contact is selected
    while (!iOperationComplete)
    {
    	Wait();
    }
    
    CleanupStack::PopAndDestroy(serviceHandler);
    
    if(iContactLink && !CheckSpaceBelowCriticalLevelL())
    {
    	iRetrieveComplete = EFalse;
    	
    	MVPbkContactOperationBase* operation = iContactManager->RetrieveContactL( *iContactLink, (*this ));
	      
	    if(operation)
	    {
			(*iSdmArray)[aIndex].SetOperation(operation,TSpdiaIndexDataVPbk::OPERATION_ASSIGN);
			
			while (!iRetrieveComplete)
		    {
		    	Wait();
		    }
		    
		    ShowRemove(aIndex);
			if(iError == 0)
			{
				
			}   	
	    }
	    
    }
}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::HandleNotifyL
//
// --------------------------------------------------------------------------
//
TInt CSpeedDialPrivate::HandleNotifyL(
        TInt aCmdId,
        TInt aEventId,
        CAiwGenericParamList& aEventParamList,
        const CAiwGenericParamList& /*aInParamList*/)
{
    TInt result = 0;
    iContactLink = NULL;
    
      if ((aCmdId == KAiwCmdSelect) || (aCmdId == KAiwCmdAssign))
        {
        if (aEventId == KAiwEventCompleted)
            {
            TInt index = 0;
            const TAiwGenericParam* param =
                aEventParamList.FindFirst(index, EGenericParamContactLinkArray);
            if ( !iFetchmail && param)
                {
                TPtrC8 contactLinks = param->Value().AsData();
                CVPbkContactLinkArray* links = CVPbkContactLinkArray::NewLC(
                        contactLinks,iContactManager->ContactStoresL());
	            
	            if(links->Count() > 0)
	           	{
	           	    if(iContactLink)
		         	{
		   	        	delete iContactLink;
		   		        iContactLink= NULL;
		   	         }
		  
	           		iContactLink = links->At(0).CloneLC();
	           		CleanupStack::Pop();
	           	}
	           	
                CleanupStack::PopAndDestroy(links);
                }
                
            index = 1;
            const TAiwGenericParam* paramMail =
                aEventParamList.FindFirst(index, EGenericParamContactFieldData);   
            if ( iFetchmail && paramMail )
            	{  
                TInt length = paramMail->Value().AsDes().Length();
                iMail = HBufC::NewL(length);
                iMail->Des().Append(paramMail->Value().AsDes());
            	}            
	            iOperationComplete = ETrue;
	    		Release();
	  
            }
        else if (aEventId == KAiwEventCanceled)
            {
            	iError = KErrCancel;    
	            iOperationComplete = ETrue;
	    		Release();
            }
         else if (aEventId == KAiwEventError)
         	{
         	   	iError = KErrInUse;    
	           	iOperationComplete = ETrue;
	    		Release();
         	}
         else if(aEventId == KAiwEventQueryExit)	
         	{
                iError = KLeaveExit;    
	            iOperationComplete = ETrue;
	    		Release();
                result = 1;
           	}
       }

    return result;
 }

// --------------------------------------------------------------------------
// CSpeedDialPrivate::ContactOperationCompleted
//
// --------------------------------------------------------------------------
//
void CSpeedDialPrivate::ContactOperationCompleted(TContactOpResult /*aResult*/)
{
	iOperationComplete = ETrue;
	Release();

}

// --------------------------------------------------------------------------
// CSpeedDialPrivate::ContactOperationFailed
//
// --------------------------------------------------------------------------
//
void CSpeedDialPrivate::ContactOperationFailed(TContactOp /*aOpCode*/, TInt aErrorCode, 
        							TBool /*aErrorNotified*/)
{
	iError = aErrorCode;
	iOperationComplete = ETrue;
	Release();
}

// ---------------------------------------------------------
// CSpeedDialPrivate::InitIndexDataL
// The SDM control data is initialized.
// ---------------------------------------------------------
//
void CSpeedDialPrivate::InitIndexDataL()
{
    // The dialog of grid is not closed.
    if (iIconArray != NULL)
    {
        iError = KErrNone;
        ResetArray();
        //State set to identify the source of call during callback.
        
        //Save the old state
        eSpeedDialState oldState = iState;
        
        iState = STATE_INITIAL;
        iOperationComplete = EFalse;

		/*Delete already fetched contacts if any */
		if(iContactLinkArray != NULL)
		{
			delete iContactLinkArray;
			iContactLinkArray = NULL;
		}
        //Fetch all contacts for which speed dial attribute is set.
        iFetchAll = EFalse;
        iSpeedDial->SetIndex(CVPbkSpeedDialAttribute::KSpeedDialIndexNotDefined);
       // iSpeedDial->SetIndex(2);
       	MVPbkContactOperationBase* findOperation = iAttributeManager->ListContactsL(*iSpeedDial,(*this));
       
        while(findOperation != NULL && !iFetchAll)
        {
        	//Wait till every contactlink is fetched and set.
        	Wait();
        }
        //Delete the handle
        delete findOperation;
        
        MVPbkContactOperationBase* retrieveOperation = NULL;
        for(TInt count =0; iContactLinkArray && count < iContactLinkArray->Count();++count)
        {
        	iRetrieveComplete = EFalse;     
        	iContactLink = &(iContactLinkArray->At(count));
	 		retrieveOperation = iContactManager->RetrieveContactL(iContactLinkArray->At(count),(*this ));
			while(retrieveOperation != NULL && !iRetrieveComplete)
			{
				//Wait till the contact is fetched and its speed dial 
				//index is initialized.
				Wait();
			}
			//Delete the handle received
			delete retrieveOperation;

        }
        // Undo this reset 
        // Just for debugging...
        if(iError != KErrNone)
        {
        	iError = KErrNone;
        }
		//Reset the state 
		iState = oldState;
    
    }
}

// ---------------------------------------------------------
// CSpeedDialPrivate::FindCompleteL
// .
// ---------------------------------------------------------
//
void CSpeedDialPrivate::FindCompleteL(MVPbkContactLinkArray* aResults)
{
	
	iContactLinkArray = aResults;
	iFetchAll = ETrue;
	Release();
	
	
}

// ---------------------------------------------------------
// CSpeedDialPrivate::FindFailed
// 
// ---------------------------------------------------------
//
void CSpeedDialPrivate::FindFailed(TInt aError)
{
	iError = aError;
	iFetchAll = ETrue;
	Release();
}
// ---------------------------------------------------------
// CSpdiaContainer::CreateItemDescriptorL
//
// ---------------------------------------------------------
//
HBufC* CSpeedDialPrivate::CreateItemDescriptorLC(const TSpdiaIndexDataVPbk& aSdmData)
    {
    HBufC* des = HBufC::NewLC(KApaMaxAppCaption);
    TPtr ptr(des->Des());

    // thumb type
    TInt type(CSpdiaGridVPbk::EText);
    if (aSdmData.ThumbIndex() >= 0)
        {
        type = ConvThumbType(aSdmData.ThumbSize());
        }

    // Text
    if ( type == CSpdiaGridVPbk::EText )
        {
        // number type icon is missing
        TBuf<KPhCltNameBufferLength> iconInfo;
        iconInfo.Append( KDesTab );       // 1
        if ( aSdmData.IconIndex() >= 0 )
            {
            iconInfo.AppendNum( aSdmData.IconIndex() );
            }
        AppendTextL( aSdmData, ptr ); //  2,3,4
        ptr.Insert( 0, iconInfo );
        }
    else
        {
        // icon + text + text + text
        ptr.Append(KDesTab2);       // 1, 2
        ptr.Append(KDesTab2);       // 2
        }

    // thumbnail 5-14
    for (TInt i(CSpdiaGridVPbk::EtnCIF90); i <= CSpdiaGridVPbk::EtnCOM; ++i)
        {
        AppendThumbnail(aSdmData, ptr, (type == i? ETrue: EFalse));
        }

    // number
    ptr.Append(KDesTab);        // 15
    // check
    ptr.Append(KDesTab);        // 16

    return des;
    }


// ---------------------------------------------------------
// CSpeedDialPrivate::CreateDataL
// Set grid used flag and calls CreateDataL.
// ---------------------------------------------------------
//
TBool CSpeedDialPrivate::CreateDataL(const CAknGrid& aGrid)
    {
    TGridUse  oldStatus;
    
    TBool result;
    
    oldStatus = iGridUsed;
    
    iGridUsed = EGridUseAndUpdate;

    result = CreateGridDataL(CONST_CAST(CAknGrid*, &aGrid), KNullIndexData);
    
    iGridUsed = oldStatus;
    
    return result;
    }
    
    	
// ---------------------------------------------------------
// CSpeedDialPrivate::AppendTextL
// output Text1\tText2\tText3\t
// ---------------------------------------------------------
//
void CSpeedDialPrivate::AppendTextL(const TSpdiaIndexDataVPbk& aSdmData, TPtr& aText)
{
    
    if (aSdmData.Contact() == NULL)
    {
      aText.Append(KDesTab2);
      aText.Append(KDesTab2);
    }
    else
    {
	   	// Test application name formatting logic is that take last name and
	    // first name and combine them using space as a separator. If either of
	    // them exists use company name. If there are still no name use "Unnamed"
	    
	    // Get field types from the master field type list
	    const MVPbkFieldType* lastNameType = 
	        iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_LASTNAME );
	    const MVPbkFieldType* firstNameType =
	        iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_FIRSTNAME );            
	    const MVPbkFieldType* companyNameType =
	        iContactManager->FieldTypes().Find( R_VPBK_FIELD_TYPE_COMPANYNAME );
	    
	    CDesCArrayFlat* bufs = new( ELeave ) CDesCArrayFlat( 2 );
	    CleanupStack::PushL( bufs );
	    
	    // Non-graphical characters are replaced with space
	    const TText KReplaceChar = ' ';
	        
	    // Contact should have only one last name field
	    CVPbkBaseContactFieldTypeIterator* itr = 
	        CVPbkBaseContactFieldTypeIterator::NewLC( *lastNameType, 
	            aSdmData.Contact()->Fields() );
	    while ( itr->HasNext() )
	        {
	        const MVPbkBaseContactField* field = itr->Next();
	        // last name field is text data
	        const MVPbkContactFieldTextData& data = 
	            MVPbkContactFieldTextData::Cast( field->FieldData() );
	        HBufC* lastName = data.Text().AllocLC();
	        
	        TPtr lName(NULL, 0);
	        lName.Set( lastName->Des() );
         	ReplaceNonGraphicCharacters( lName, KReplaceChar );
         	
         	const TInt 	len = lName.Length();
         	if (0 < len)
         	{
         		bufs->AppendL( lName);
         	}
	        
	        CleanupStack::PopAndDestroy( lastName );
	        }
	    CleanupStack::PopAndDestroy( itr );
	    
	    // Contact should have only one first name field
	    itr = CVPbkBaseContactFieldTypeIterator::NewLC( *firstNameType, 
	        aSdmData.Contact()->Fields() );
	    while ( itr->HasNext() )
	        {
	        const MVPbkBaseContactField* field = itr->Next();
	        // last name field is text data
	        const MVPbkContactFieldTextData& data = 
	            MVPbkContactFieldTextData::Cast( field->FieldData() );
	        
	        HBufC* firstName = data.Text().AllocLC();

	        TPtr fName(NULL, 0);
	        fName.Set( firstName->Des() );
         	ReplaceNonGraphicCharacters( fName, KReplaceChar );
         	
         	const TInt 	len = fName.Length();
         	if (0 < len)
         	{
         		bufs->AppendL( fName);
        	}
	        
			CleanupStack::PopAndDestroy( firstName );
	        }
	    CleanupStack::PopAndDestroy( itr );
	    
	    // No last and first name try company name
	    if ( bufs->Count() == 0 )
	        {
	        // Contact should have only one company name field
	        itr = CVPbkBaseContactFieldTypeIterator::NewLC( *companyNameType, 
	            aSdmData.Contact()->Fields() );
	        while ( itr->HasNext() )
	            {
	            const MVPbkBaseContactField* field = itr->Next();
	            // last name field is text data
	            const MVPbkContactFieldTextData& data = 
	                MVPbkContactFieldTextData::Cast( field->FieldData() );
	            HBufC* companyName = data.Text().AllocLC();
	            bufs->AppendL( *companyName );
	            CleanupStack::PopAndDestroy( companyName );
	            }
	        CleanupStack::PopAndDestroy( itr );
	        }
	    
	  	aText.Append(KDesTab);
	    // If still no name use phone number
	    if ( bufs->Count() == 0 )
	        {
            	aText.Append(aSdmData.PhoneNumber());
            	aText.Append(KDesTab); 
	        }
	    else
	    {
		    for ( TInt i = 0; i < bufs->Count(); ++i )
		    {
		        aText.Append( (*bufs)[i] );
		        aText.Append(KDesTab);
		    }
	    	
	    }
	    
		aText.Append(KDesTab);
	    CleanupStack::PopAndDestroy( bufs );	
    }
    
	AknTextUtils::DisplayTextLanguageSpecificNumberConversion (aText);
}
   

// ---------------------------------------------------------
// CSpdiaContainer::SetOperationsL
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::SetOperationsL()
    {
    for (TInt index(iSdmArray->Count() -1); index > 0; --index)
        {
        TSpdiaIndexDataVPbk& data = (*iSdmArray)[index];
        
        if (data.ThumbIndex() >=0)
            {
            iOperationComplete = EFalse;
            data.SetImageOperation(
                    iImageManager->GetImageAsyncL(NULL,*(data.Contact()),*iThumbNailFieldType,(*this) ) );
            while ( !iOperationComplete )
                {
                Wait();
                }
            }
        }
    }

// ---------------------------------------------------------
// CSpdiaContainer::UpdateIndexDataL
//
// ---------------------------------------------------------
//

TBool CSpeedDialPrivate::UpdateIndexDataL(TInt aIndex)
    {
	CFbsBitmap* bitmap,*mask;
	bitmap = NULL;
	mask= NULL;
	MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance();
	

    TSpdiaIndexDataVPbk& data = (*iSdmArray)[aIndex];
    delete (*iIconArray)[aIndex];
    (*iIconArray)[aIndex] = NULL;
    TFileName bmpPath(iBmpPath);

	if(	User::Language() == ELangHindi )
	{
		AknsUtils::CreateIconL(skinInstance, (*iDialSkinBmp)[aIndex],bitmap,mask,bmpPath,iDialHindiBmp[aIndex],  iDialHindiBmpMask[aIndex] );
	}
	else
	{
		AknsUtils::CreateIconL(skinInstance, (*iDialSkinBmp)[aIndex],bitmap,mask,bmpPath,iDialBmp[aIndex],  iDialBmpMask[aIndex] );
	}
	(*iIconArray)[aIndex] = CGulIcon::NewL(bitmap,mask);
	
	
	
	MVPbkStoreContact* aContact = data.Contact();

    data.ResetThumbIndex();
    if (CreateIndexIconL(aIndex, data, ETrue))
        {
        
    	if (iImageManager)
    	{
    		data.SetImageOperation( iImageManager->GetImageAsyncL(NULL,*aContact,*iThumbNailFieldType,(*this) ) );
    	}
        }
    else
        {
        ChangeIndexDataL(aIndex, data);
        iGrid->DrawNow();
        }
    return ETrue;
    }
   

// ---------------------------------------------------------
// CSpdiaContainer::CreateIndexIconL
//
// ---------------------------------------------------------
//
TBool CSpeedDialPrivate::CreateIndexIconL(TInt aIndex,
                 TSpdiaIndexDataVPbk& aSdmData, TBool aSetUpdateThumb)
    {
    TBool existThumb(EFalse);

  	if (aSdmData.Contact() != NULL)
    {
	    TInt fieldId = -1;	   
	    
	    MVPbkStoreContactField* field = (*iSdmArray)[aIndex].Field();	
		if(field)
		{
			fieldId = field->BestMatchingFieldType()->FieldTypeResId();
		}
	    aSdmData.SetIconIndex(FindIconIndex(fieldId));     
	   
		// check for the functionality, why he is checking has thumbnail before adding
		
		if (iImageManager->HasImage(*aSdmData.Contact(),*iThumbNailFieldType))
		{
			existThumb = ETrue;
	        if (aSetUpdateThumb)
	        {
	            aSdmData.SetLastThumb(ETrue);
	        }
	        aSdmData.SetThumbIndex(aIndex, NULL);
	    }
	    else
	    {
	    	aSdmData.SetThumbIndex(-1, NULL);
	    }
	    
    }
         
    return existThumb;
    }

// ---------------------------------------------------------
// CSpdiaContainer::ChangeIndexDataL
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::ChangeIndexDataL(
    TInt aIndex,
    const TSpdiaIndexDataVPbk& aSdmData )
    {
    CDesCArray* array = STATIC_CAST(CDesCArray*,
                        iGrid->Model()->ItemTextArray());
    HBufC* des = ItemDescriptorLC(aIndex, aSdmData);
    array->Delete(aIndex);
    array->InsertL(aIndex, *des);
    CleanupStack::PopAndDestroy(); // des
    }
    
    
// ---------------------------------------------------------
// CSpeedDialPrivate::FindIconIndex
//
// ---------------------------------------------------------
//

TInt CSpeedDialPrivate::FindIconIndex(TInt aId) const
    {
    TInt index(KNullIndexData);
    for (TInt n(0); index == KNullIndexData && n < (sizeof KFieldIds/sizeof KFieldIds[0]); ++n)
        {
       if ((TUint)aId == KFieldIds[n] )
            {
            index = n + iSdmCount;
            }
        }
    return index;
    }
    

// ---------------------------------------------------------
// CSpdiaContainer::ItemDescriptorL
//
// ---------------------------------------------------------
//
HBufC* CSpeedDialPrivate::ItemDescriptorLC(TInt aIndex,
                            const TSpdiaIndexDataVPbk& aSdmData)
    {
    HBufC* des = NULL;
    if (aSdmData.Contact() != NULL)
        {
        des = CreateItemDescriptorLC(aSdmData);
        }
    else
        {
        des = HBufC::NewLC(KNullCell.iTypeLength);
        des->Des().Format(KNullCell, aIndex);
        }
    return des;
    }
    
// ---------------------------------------------------------
// CSpdiaContainer::SetItemDataL
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::SetItemDataL(CDesCArray& aArray)
    {
    for (TInt loop(0); loop < iSdmCount; loop++)
        {
        TSpdiaIndexDataVPbk& data = (*iSdmArray)[loop];

        aArray.AppendL(ItemDescriptorLC(loop, data)->Des());
        CleanupStack::PopAndDestroy(); // des
        }
    }
    
TBool CSpeedDialPrivate::CheckSpaceBelowCriticalLevelL()
    {
    TBool retcode(EFalse);

    if (SysUtil::FFSSpaceBelowCriticalLevelL(&(iCoeEnv->FsSession())))
        {
        CErrorUI* errorUi = CErrorUI::NewLC();
        errorUi->ShowGlobalErrorNoteL(KErrDiskFull);
        CleanupStack::PopAndDestroy(); // errorUi
        retcode = ETrue;
        }
    return retcode;
    }

// ---------------------------------------------------------
// CSpeedDialPrivate::GetThumbnailSize()
// Gets actual size of thumbnial to be drawn
// ---------------------------------------------------------
//
TSize CSpeedDialPrivate::GetThumbnailSize()
{
	TRect mainPaneRect ;
    TRect statusPaneRect;
    TInt  varient =0;

	if (Layout_Meta_Data::IsLandscapeOrientation())
	{
	 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane,mainPaneRect);
	 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EStatusPane,statusPaneRect);
	 mainPaneRect.iTl = statusPaneRect.iTl;
	 mainPaneRect.iBr.iY = mainPaneRect.iBr.iY - statusPaneRect.iTl.iY;
	 varient =1;
	}
	else
	{
	 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane,mainPaneRect);
	 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EStatusPane,statusPaneRect);
	 mainPaneRect.iTl= statusPaneRect.iTl;
	}
		
	TAknLayoutRect mainGridPaneRect;
	TAknLayoutRect gridPaneRect;
	TAknLayoutRect cellPaneRect;
	TAknLayoutRect thumbPaneRect;
	
	mainGridPaneRect.LayoutRect(mainPaneRect,AknLayoutScalable_Apps::main_qdial_pane());//main grid pane
	gridPaneRect.LayoutRect(mainGridPaneRect.Rect(),AknLayoutScalable_Apps::grid_qdial_pane());//main grid pane
	cellPaneRect.LayoutRect(gridPaneRect.Rect(),AknLayoutScalable_Apps::cell_qdial_pane(0,0));
	thumbPaneRect.LayoutRect(cellPaneRect.Rect(),AknLayoutScalable_Apps::thumbnail_qdial_pane(varient));

	return thumbPaneRect.Rect().Size();

}
	

// ---------------------------------------------------------
// CSpeedDialPrivate::ThumbType
// An interface for accessing index data array.
// ---------------------------------------------------------
//
TInt CSpeedDialPrivate::ThumbType(TInt aIndex) const
    {
    return ConvThumbType((*iSdmArray)[aIndex].ThumbSize());
    }
    
// ---------------------------------------------------------
// CSpeedDialPrivate::ThumbSize
// An interface for accessing index data array.
// ---------------------------------------------------------
//
TSize CSpeedDialPrivate::ThumbSize(TInt aIndex) const
    {
    return (*iSdmArray)[aIndex].ThumbSize();
    }
    
// ---------------------------------------------------------
// CSpdiaContainer::ConvThumbType
// Returns
//      EtnVGA  : 640 x 480 40 x 30 VGA
//      EtnVGA90: 480 x 640 30 x 40 VGA turned
//      EtnCIF  : 352 x 288 44 x 36 CIF
//      EtnCIF90: 288 x 352 36 x 44 CIF turned
//      EtnCOM  : othre
// ---------------------------------------------------------
//
TInt CSpeedDialPrivate::ConvThumbType(const TSize& aSize) const
    {
	// Scalable UI
	TAknWindowLineLayout  vga;
	TAknWindowLineLayout  cif;
	if( AknLayoutUtils::ScalableLayoutInterfaceAvailable() )
	{
	 vga = AknLayoutScalable_Apps::popup_phob_thumbnail_window_g2().LayoutLine();
	 cif = AknLayoutScalable_Apps::popup_phob_thumbnail_window_g1().LayoutLine();//image

	}
	else
	{
	 vga = AppLayout::Thumbnail_pop_up_window_elements_Line_1();
	 cif = AppLayout::Thumbnail_pop_up_window_elements_Line_3();

	}
    TInt type(CSpdiaGridVPbk::EtnCOM);

    if (aSize.iWidth == cif.iH//SDM_TN_CIF_HEIGHT
            && aSize.iHeight == cif.iW)// SDM_TN_CIF_WIDTH)
        {
        type = CSpdiaGridVPbk::EtnCIF90;
        }
    else if (aSize.iWidth == cif.iW &&//SDM_TN_CIF_WIDTH &&
                    aSize.iHeight ==  cif.iH)//SDM_TN_CIF_HEIGHT)
        {
        type = CSpdiaGridVPbk::EtnCIF;
        }
    else if (aSize.iWidth == vga.iH &&//SDM_TN_VGA_HEIGHT &&
                    aSize.iHeight == vga.iW )//SDM_TN_VGA_WIDTH)
        {
        type = CSpdiaGridVPbk::EtnVGA90;
        }
    else if (aSize.iWidth == vga.iW &&//SDM_TN_VGA_WIDTH &&
                    aSize.iHeight == vga.iH)//SDM_TN_VGA_HEIGHT)
        {
        type = CSpdiaGridVPbk::EtnVGA;
        }

    return type;
    }

// ---------------------------------------------------------
// CSpdiaContainer::AppendThumbnail
// output \tThumbnail\ticon
// ---------------------------------------------------------
//
void CSpeedDialPrivate::AppendThumbnail(
    const TSpdiaIndexDataVPbk& aSdmData,
    TPtr& aText,
    TBool aFixedLocation )
    {
    if (!aFixedLocation)
        {
        aText.Append(KDesTab2);
        return;
        }

    aText.Append(KDesTab);
    if ( aSdmData.ThumbIndex() >= 0 && aSdmData.ThumbSize().iWidth > 0 )
        {
        aText.AppendNum(aSdmData.ThumbIndex());
        }

    aText.Append(KDesTab);
    if (aSdmData.IconIndex() >= 0)
        {
        aText.AppendNum(aSdmData.IconIndex());
        }
    }
	




// ---------------------------------------------------------
// CSpeedDialPrivate::AssignSpeedDial
//
// ---------------------------------------------------------
//

TBool CSpeedDialPrivate::AssignSpeedDialL(TInt aIndex)
{
	TBool aReturn (EFalse);
	
	MVPbkContactOperationBase* operation = NULL;

	iSpeedDial->SetIndex(aIndex+1);	
	
	iOperationComplete = EFalse;
	(*iSdmArray)[aIndex].Contact()->LockL(*this);
	
	while(!iOperationComplete)
	{
		Wait();
	}
	if(iError == KErrNone)
	{
		
		MVPbkStoreContactField* field = (*iSdmArray)[aIndex].Field();
		iOperationComplete = EFalse;
		
		if( field != NULL)
		{
			operation = iAttributeManager->SetFieldAttributeL( *field, *iSpeedDial, ( *this ) );
		}
	
		if(operation != NULL)
		{
			(*iSdmArray)[aIndex].SetOperation(operation,TSpdiaIndexDataVPbk::OPERATION_ASSIGN);
			while(!iOperationComplete)
			{
				Wait();
			}
		
		}
		if(iError == KErrNone)
		{
			aReturn = ETrue;
		}
	}

	return aReturn;		
}



// ---------------------------------------------------------
// CSpeedDialPrivate::RemoveSpeedDial
//
// ---------------------------------------------------------
//

TBool CSpeedDialPrivate::RemoveSpeedDialL(TInt aIndex)
{
	TBool aReturn (EFalse);
	
	if((*iSdmArray)[aIndex].Field() != NULL)
	{
		iError = KErrNone;
		
		iOperationComplete = EFalse;
		iSpeedDial->SetIndex(aIndex+1);
		(*iSdmArray)[aIndex].Contact()->LockL(*this);
			
		while(!iOperationComplete)
		{
				Wait();
		}
		
	if(iError == KErrNone)
		{
			iOperationComplete = EFalse;
			MVPbkContactOperationBase* operation = iAttributeManager->RemoveFieldAttributeL(
													*((*iSdmArray)[aIndex].Field()), *iSpeedDial, (*this));
			
			if(operation)
			{
				
				(*iSdmArray)[aIndex].SetOperation(operation,TSpdiaIndexDataVPbk::OPERATION_REMOVE);
			
				while(!iOperationComplete)
				{
					Wait();
				}

			}
			
			if(iError == KErrNone)
			{
				aReturn = ETrue;
			}
		}
	}

	return aReturn;
}

// ---------------------------------------------------------
// CSpeedDialPrivate::ContactTitleL
//
// ---------------------------------------------------------
//

EXPORT_C HBufC* CSpeedDialPrivate::ContactTitleL( MVPbkBaseContact* aContact, TBool aUnnamed )
{


	HBufC* title = NULL;
	
	if (aContact != NULL)
	{
		CPbk2SortOrderManager* sortOrderManager = CPbk2SortOrderManager::NewL( iContactManager->FieldTypes() );
       
	    MPbk2ContactNameFormatter* nameFormatter = Pbk2ContactNameFormatterFactory::CreateL(
	                        iContactManager->FieldTypes(), 
	                        *sortOrderManager );
        title = nameFormatter->GetContactTitleOrNullL( aContact->Fields(), KContactFormattingFlags );
	    
	    if (title == NULL && aUnnamed)
	    {
	    	title = nameFormatter->UnnamedText().AllocL();	
	    }
	    
	    delete sortOrderManager;
	    delete nameFormatter;
	}
  
    return title;
                        
}

// ---------------------------------------------------------
// CSpeedDialPrivate::Release
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::Release(  )
     {
     
    
     if( iWait->IsStarted() )
         {
         iWait->AsyncStop();
         }
     }
   
// ---------------------------------------------------------
// CSpeedDialPrivate::Wait
//
// ---------------------------------------------------------
//
void CSpeedDialPrivate::Wait()
{
   if( !(iWait->IsStarted()) ) 
    	iWait->Start();

}

// ---------------------------------------------------------
// CSpeedDialPrivate::Cancel
// To cancel the aiw event
// ---------------------------------------------------------
//
TBool CSpeedDialPrivate::Cancel()
{
	if(!iOperationComplete)
	{
		iOperationComplete = ETrue;
	}
	if(iQueryDialog)
	{
		delete iQueryDialog;
		iQueryDialog = NULL;
	}
    if ( iServiceHandler )
        {
        TRAP_IGNORE(
                {
                CAiwGenericParamList& inParamList =  iServiceHandler->InParamListL();
                CAiwGenericParamList& outParamList =  iServiceHandler->OutParamListL();
                iServiceHandler->ExecuteServiceCmdL(
                    KAiwCmdAssign, 
                    inParamList,
                    outParamList,
                    KAiwOptCancel, NULL );
                }
            )
        }
    
    Release();
    iCancelFlag = ETrue;
    return ETrue;
}

// ---------------------------------------------------------
// CSpeedDialPrivate::GetWait
// Monitor iWait
// ---------------------------------------------------------
//
EXPORT_C CActiveSchedulerWait* CSpeedDialPrivate::GetWait()
 {
  return iWait;	
 }

// ---------------------------------------------------------
// CSpeedDialPrivate::ReplaceNonGraphicCharacters
// To replace nongraphic characters (e.g.:- newline)
// ---------------------------------------------------------
//
void CSpeedDialPrivate::ReplaceNonGraphicCharacters( TDes& aText, TText aChar )
    {
    const TInt len = aText.Length();

    const TUint KPbkZWSCharacter = 0x200B;
    const TUint KPbkZWNJCharacter = 0x200C;

    // Zero Width Space character
    const TChar zwsChar( KPbkZWSCharacter );
    // Zero Width Non-Joiner character
    const TChar zwnjChar( KPbkZWNJCharacter );

    for ( TInt i=0; i < len; ++i )
        {
        if ( !TChar(aText[i]).IsGraph() &&
             ( (zwsChar != aText[i]) && (zwnjChar != aText[i]) ) )
            {
            // If non-graphic char is specified in ZWSCharacter,
            // it will not be replaced. Otherwise replace non-graphic
            // character with aChar.
             aText[i] = aChar;
	        }
        }

    aText.Trim();
}

// ---------------------------------------------------------
// CSpeedDialPrivate::SetRefreshObserver
// Set refresh observer.
// ---------------------------------------------------------
//
EXPORT_C  void CSpeedDialPrivate::SetRefreshObserver( MRefreshObserver* aObserver )
    {
    iRefreshObserver = aObserver;
    }

// ---------------------------------------------------------
// CSpeedDialPrivate::SetCurrentGridIndex
// set the currentindex
// ---------------------------------------------------------
//
EXPORT_C void CSpeedDialPrivate::SetCurrentGridIndex( TInt aCurrentGridIndex )
 	{
	iCurrentIndex = aCurrentGridIndex;
	}


// ---------------------------------------------------------
// CSpeedDialPrivate::SetGridDataAsNull
// Set iGrid and iIconArray as Null
// ---------------------------------------------------------
//
EXPORT_C void CSpeedDialPrivate::SetGridDataAsNull()
	{
	iGrid = NULL;
	iIconArray = NULL;
	}
// ---------------------------------------------------------
// CSpeedDialPrivate::SetCurrentGridIndex
// set the currentindex
// ---------------------------------------------------------
//
void CSpeedDialPrivate::ShowNoteL( TInt aResourceId )
    {
    HBufC* prompt = StringLoader::LoadLC( aResourceId );
    CAknInformationNote* dlg = new ( ELeave ) CAknInformationNote( EFalse );
    dlg->ExecuteLD( *prompt );
    CleanupStack::PopAndDestroy(); // prompt
    }
// End of the file

