void AppendInterfaceProperties(TDes& aDes, const SCdlInterface& aInterface)
	{
	aDes.AppendFormat(_L("%S\nUid: 0x%08x\nMajorVer: %d\nMinorVer: %d\nFlags: 0x%08x\nAPI size: %d\nEng major: %d\nEng minor: %d"), 
		aInterface.iName,
		aInterface.iUid,
		aInterface.iMajorVer,
		aInterface.iMinorVer,
		aInterface.iFlags,
		aInterface.iApiSize,
		aInterface.iMajorEngVer,
		aInterface.iMinorEngVer
		);
	}

/*
 * ActiveCall() detects if there's a connected call. Only in that case aNumber is meaningfull; and only 
 * in that case, if aNumber.Length() == 0, then aNumber is a private number.
 */
TBool CPhoneCallMonitor::ActiveCall(TDes& aNumber)
	{
	CTelephony::TRemotePartyInfoV1 remInfoUse;
	CTelephony::TCallInfoV1		   callInfoUse;
	CTelephony::TCallSelectionV1   callSelectionUse;
	  		
	// we are interested only voice lines
	callSelectionUse.iLine = CTelephony::EVoiceLine;
	// and calls that are currently connected
	callSelectionUse.iSelect = CTelephony::EActiveCall;  //EHeldCall, EInProgressCall
	  		
	CTelephony::TRemotePartyInfoV1Pckg 	remParty(remInfoUse);
	CTelephony::TCallInfoV1Pckg 		callInfo(callInfoUse);
	CTelephony::TCallSelectionV1Pckg 	callSelection(callSelectionUse);
	  	
	// TCallRemoteIdentityStatus::ERemoteIdentityUnknown, ERemoteIdentityAvailable, ERemoteIdentitySuppressed
	if(iTelephony->GetCallInfo(callSelection,callInfo,remParty) == KErrNone)
		{
		if(remInfoUse.iDirection == CTelephony::EMobileOriginated) //outgoing call
			{
			aNumber.Copy(callInfoUse.iDialledParty.iTelNumber);
			}
		else   //incoming call
			{
			if(remInfoUse.iRemoteIdStatus == CTelephony::ERemoteIdentityAvailable)
				{
				aNumber.Copy(remInfoUse.iRemoteNumber.iTelNumber);
				}
			else  // private number
				{
				aNumber.Zero();
				}
			}
		return ETrue;
		}
	
	return EFalse;
	}

EXPORT_C TInt TFsPluginRequest::FileName(TDes& aName)
	{
	//Special handling required for directories.
	switch(Function())
		{
		case EFsDirOpen:
		case EFsSetEntry:
			{
			aName.Copy(Request()->Src().FullName());
			break;
			}
		case EFsDirReadOne:
		case EFsDirReadPacked:
		case EFsDirSubClose:
			{
			//Get the name from CDirCB::iName
			CDirCB* dir = (CDirCB*) ScratchValue();
			__ASSERT_ALWAYS(dir!= NULL, Fault(EPluginOpError));
			TName name = dir->Name();
			if(name.Size() == 0)
				{
				return KErrNotFound;
				}
			aName.Copy(name);
			break;
			}
		default:
			{
			CFileShare* share;
			TInt err = ShareFromClientHandle(share);
			if(err != KErrNone || share == NULL)
				return(err);
			
			NameFromShare(*share, aName);
			}
		}
	return KErrNone;
	}

void GetTimeString(TTime t, TDes& aBuf)
{
	TBuf<5> time; 
	TTime now; now=GetTime();
	if ((now.DateTime().Year()==t.DateTime().Year()) 
	   && (now.DateTime().Month()==t.DateTime().Month())
	   && (now.DateTime().Day()==t.DateTime().Day()) ) {
		
		t.FormatL(time, _L("%F%H:%T"));
	} else {
		t.FormatL(time, _L("%F%D/%M"));
	}
	aBuf.Copy(time);
}

TBool TAzenqosEngineUtils::AskTestDescription(TInt rscid, TDes& descr)
	{
							//descr.Zero();
							CAknTextQueryDialog* cldlg;
					        cldlg = new (ELeave) CAknTextQueryDialog(descr);
					        cldlg->PrepareLC( rscid );
					        if(!(cldlg->RunLD()))
					        {
					        	return EFalse;
					        }

					        descr.TrimAll();
					        if(descr.Length()==0)
					        {
			       				_LIT(emsg,"Test description not entered");
							    CAknErrorNote* informationNote = new (ELeave) CAknErrorNote(ETrue);
							   	informationNote->ExecuteLD(emsg);
							   	return EFalse;
					        }

					        return ETrue;

	}

/**
Utility function for obtaining info on file close requests.  

@param	aRequest			File close request
@param	aPath				The path of the file
@return	KErrNone
*/
LOCAL_C TInt FileCloseVars(CFsRequest* aRequest, TDes& aFileName)
	{
	__ASSERT_ALWAYS(aRequest->Operation()->Function()==EFsFileSubClose,Fault(EBaseRequestMessage));
	
	const TDes* fileName=(TDes*) I64HIGH(aRequest->ScratchValue64());
	if(fileName == NULL)
		return(KErrBadName);

	aFileName = _L("?:");
	aFileName[0] = TText('A' + aRequest->DriveNumber());
	aFileName.Append(*fileName);
	
	return(KErrNone);
	}

TInt CSecMgrStore::GetScriptFile(TDes& aFile, TExecutableID aExecID)
	{
	TInt ret(GetScriptPath (aFile));

	if ( (KErrNone==ret) || (KErrAlreadyExists==ret))
		{
		if ( KAnonymousScript!=aExecID)
			{
			HBufC *fSuffix = HBufC::NewLC(KMaxName);
			TPtr fSuffixPtr(fSuffix->Des());
			fSuffixPtr.Num (aExecID);

			aFile.Append (fSuffixPtr);
			aFile.Append (KDatExtn);
			CleanupStack::PopAndDestroy (fSuffix);
			}
		}

	if ( KErrAlreadyExists==ret)
		ret=KErrNone;

	return ret;
	}

EXPORT_C void TextUtils::ClipToFit(TDes& aBuffer,const CFont& aFont,TInt aMaxWidthInPixels,TChar aAlternativeEnd)
/** Clips text to fit into a maximum width.

If the text is too wide to fit in the width when displayed in aFont, 
it is truncated and the specified character (by default, 
a horizontal ellipsis) is appended to it.

@param aBuffer A buffer containing the text to clip.
@param aFont The font.
@param aMaxWidthInPixels The maximum width in pixels.
@param aAlternativeEnd The Unicode character to append to the buffer if truncated. 
By default, this is the horizontal ellipsis. */
	{
	TInt textWidth=aFont.TextWidthInPixels(aBuffer);
	if (textWidth<=aMaxWidthInPixels)
		return;
	TBuf<1> ellipse;
	ellipse.Append(aAlternativeEnd);
	TInt extraWidth=aFont.TextWidthInPixels(ellipse);
	TInt cutOff=aFont.TextCount(aBuffer,aMaxWidthInPixels-extraWidth);
	aBuffer.SetLength(cutOff);
	aBuffer.Append(ellipse);
	}

// ---------------------------------------------------------------------------
// If aDevExt contains a valid friendly name, the friendly name will be displayed;
// Otherwise, if the given name from the parameter of a notifier request is valid,
// the given name will be displayed;
// Otherwise, If aDevExt contains a valid device name, the name will be displayed;
// Otherwise, the a name will be created by this function.
// ---------------------------------------------------------------------------
//
void TBTNotifUtil::GetDeviceUiNameL( TDes& aNameBuf, 
            const CBtDevExtension* aDevExt, 
            const TDesC& aNameInParam,
            const TBTDevAddr& aAddr)
    {
    CBtDevExtension* tempDev( NULL );
    TPtrC namePtr;
    if ( aDevExt && 
         aDevExt->Device().IsValidFriendlyName() && 
         aDevExt->Device().FriendlyName().Length() != 0 )
        {
        // We always use the friendly name regardless of 
        // the device-name of the device is available or not.
        namePtr.Set( aDevExt->Device().FriendlyName() );
        }
    else 
        {
        // this will take care of name formating. Either the
        // name from iNameInParam or the address will be
        // the alias:
        tempDev = CBtDevExtension::NewLC( aAddr, aNameInParam );      
        namePtr.Set( tempDev->Alias() );
        }
    // Make sure no overflow:
    if ( aNameBuf.MaxLength() < namePtr.Length() )
        {
        aNameBuf.Copy( namePtr.Left( aNameBuf.MaxLength() ) );
        }
    else
        {
        aNameBuf.Copy( namePtr );
        }
    if ( tempDev )
        {
        CleanupStack::PopAndDestroy( tempDev );
        }
    }

void CSCOMOAdapterDb::PrepareLuidQuery(TInt aLuid, TDes& aSqlQuery)
{
	aSqlQuery.Copy(_L("SELECT * FROM "));
    aSqlQuery.Append(KTableAMMgmtObject);
    aSqlQuery.Append(_L(" WHERE "));
    aSqlQuery.Append(NCol2);
    aSqlQuery.Append(_L(" = "));
    aSqlQuery.AppendNum(aLuid);
}

void GetAppPath(TDes& aAppPath)
{
#if defined ( EKA2 )
	User::LeaveIfError(CEikonEnv::Static()->FsSession().PrivatePath(aAppPath));
    // insert the drive to the private path
    TParsePtrC parse((CEikonEnv::Static()->EikAppUi()->Application())->AppFullName());
    aAppPath.Insert(0, parse.Drive());
#else
    CompleteWithAppPath(aAppPath);

#endif
#ifdef __WINS__
	aAppPath[0] = 'c';
#endif	
}

/**
The method parses aFileName argument and constructs the full database file name (including the path) there.
The full file name will be constructed in aFileName input/output argument.

@param aDbFileName Input/Output. Database file name will be constructed there.
@param aSysDrivePrivatePath SQL server private path on the system drive.   
@param aDrive Output parameter. The drive number.
				
@leave KErrBadName Missing file name.

@panic SqlDb 7 In _DEBUG mode - no drive in the final file path.

@internalComponent
*/
static void DoFullFileNameL(TDes& aDbFileName, const TDesC& aSysDrivePrivatePath, TDriveNumber& aDrive)
	{
	TParse parse;
	__SQLLEAVE_IF_ERROR2(parse.Set(aDbFileName, &aSysDrivePrivatePath, NULL));
	if(!parse.NamePresent())
		{
		__SQLLEAVE2(KErrBadName);	
		}
	aDbFileName.Copy(parse.FullName());
	TPtrC driveName = parse.Drive();
	__ASSERT_DEBUG(driveName.Length() > 0, __SQLPANIC2(ESqlPanicInternalError));
	TInt driveNumber = -1;
	__SQLLEAVE_IF_ERROR2(RFs::CharToDrive(driveName[0], driveNumber));
	aDrive = static_cast <TDriveNumber> (driveNumber);
	}

/**
Copy a maximum of KTextFieldMinimalLength characters from aSrc to aDest.

@param aSrc Source text buffer.
@param aDest Destination text buffer.

@return ETrue if copy was successfull, EFalse otherwise.
*/
TBool TCntPersistenceUtility::CopyMinFieldText(TPtrC aSrc,TDes& aDest)
	{
	TBool ret(EFalse);
	if(aSrc.Length() > 0)
		{
		TInt  length = aSrc.Length();
		if (length>KTextFieldMinimalLength)
			{
			length=KTextFieldMinimalLength;
			}	
		aDest.Copy(aSrc.Left(length));
		ret = ETrue;
		}
	return ret;
	}

void DegAndMinutesToGeo(const TDesC& aMin, TDes& aInto, TInt aSign)
{
	aInto.Zero();
	if (aMin.Compare(_L("0000.0000"))==0  || aMin.Compare(_L("00000.0000"))==0  || aMin.Length()<3) {
		return;
	}
	TInt decpos=aMin.Locate('.');
	if (decpos==KErrNotFound || decpos<3) return;

	TReal deg, min;
	{
		TLex lex(aMin.Left(decpos-2));
		if (lex.Val(deg)!=KErrNone) {
			return;
		}
	}

	{
		TLex lex(aMin.Mid(decpos-2));
		if (lex.Val(min)!=KErrNone) {
			return;
		}
		if (deg==TReal(0) && min==TReal(0)) return;
		min/=TReal(60);
	}

	deg+=min;

	if (deg > TReal(180)) return;

	deg*=aSign;
	TRealFormat fmt; fmt.iTriLen=0;
	fmt.iPoint='.'; fmt.iPlaces=8;
	fmt.iType=KRealFormatCalculator;
	aInto.Num(deg, fmt);
}

TInt CSecMgrStore::GetConfigFile(TDes& aConfigFile)
	{
	TInt ret(KErrNone);

	aConfigFile.Append (KCDrive);

	HBufC *privateDir = HBufC::NewLC(KMaxName);
	TPtr ptr(privateDir->Des());
	ret = iFsSession.PrivatePath (ptr);

	if ( KErrNone==ret)
		{
		aConfigFile.Append (ptr);

		ret = iFsSession.MkDirAll (ptr);

		if ( KErrAlreadyExists==ret)
			ret=KErrNone;

		aConfigFile.Append (KConfigFile);
		}
	CleanupStack::PopAndDestroy (privateDir);
	return ret;
	}

TInt CTestAgentDrmContent::GetStringAttribute(TInt aAttribute, TDes& aValue)
	{
	TInt err = KErrNone;
	switch(aAttribute)
		{
		// the content object
		case ContentAccess::EMimeType:
		aValue.Copy(*iContentMimeType);
		break;
	default:
		err = KErrCANotSupported;
		break;
		};
	return err;
	}

/*
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
*/
void CYuccaNavi::GetTextL(TDes& aText)
{
	if(iNaviDecorator)
	{
		if(iNaviDecorator->DecoratedControl())
		{
			CAknNaviLabel* Tmp = STATIC_CAST(CAknNaviLabel*, iNaviDecorator->DecoratedControl());
			
			const TDesC* Texksti = Tmp->Text();
			if(Texksti)
			{
				aText.Copy(*Texksti);
			}
		}
	}

EXPORT_C void CTestUtils::AppendText(const TDesC& aToken, TDes& aTxt, TInt aMaxTokenLength)
	{
	TInt totalLen = aTxt.Length() + aMaxTokenLength;

	aTxt.Append(aToken);
	aTxt.TrimRight();

	if (aTxt.Length() < totalLen)
		{
		aTxt.AppendFill(' ', totalLen - aTxt.Length());
		}

	aTxt.SetLength(totalLen);
	}

// ==========================================================================
// METHOD:  Constructor
//
// DESIGN:  
// ==========================================================================
CLogFileHandler::CLogFileHandler( RFs& aFs,
                                  TDes& aFormatBuffer, 
                                  TDes8& aOutputBuffer,
                                  const TDesC& aDirectoryName,
                                  const TDesC& aFileName ) : 
    iFs( aFs ),                                  
    iFormatBuffer( aFormatBuffer ),
    iFormatBuffer8( const_cast<TUint8*>(reinterpret_cast<const TUint8*>(aFormatBuffer.Ptr())), 0, aFormatBuffer.MaxLength()*2 ),
    iOutputBuffer( aOutputBuffer ),
    iDirectoryName( aDirectoryName ),
    iFileName( aFileName ),
    iTryToOpenFile( ETrue ),
    iFileIsOpen( EFalse ),
    iFirstTime( ETrue )
    {
    } // END CLogFileHandler

//Get DSC database name
void CDscDatabase::GetDatabaseNameL(TDes& aDatabaseName)
	{
	RFs fs;
	CleanupClosePushL(fs);
	User::LeaveIfError(fs.Connect());
	
	// retrieve system drive
	TDriveNumber driveNumber = fs.GetSystemDrive();
 
	// convert to char
    TChar driveChar;
    User::LeaveIfError(RFs::DriveToChar(driveNumber, driveChar));
 
	aDatabaseName.Format(KDatabaseName, (TUint)driveChar);
	CleanupStack::PopAndDestroy(&fs);
	}