/*

* Copyright (c) 2002-2007 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:  Contains the declarations for miscellanous image information.

*

*/

#include <uri8.h> // curi8

#include <uri16.h> // curi16

#include <uriutils.h> // uriutils

#include <escapeutils.h> //utf8 conversions

#include "cimageinfo.h"

#include "cxfclogger.h"

// log macros for static methods

#ifdef ENABLE_LOGGING

//#define LOCAL_LOGGING

#endif

#ifdef LOCAL_LOGGING

#define I_LOG(a) LOG(a)            

#define I_LOG1(s, v) LOG1(s, v)        

#define I_LOG2(s, v1, v2) LOG2(s, v1, v2)   

#define I_LOG8(a) LOG8(a)           

#define I_LOG81(s, v) LOG81(s, v)       

#define I_LOG82(s, v1, v2) LOG82(s, v1, v2)  

#else

#ifdef ENABLE_LOGGING

#undef ENABLE_LOGGING

#endif

#define I_LOG(a)

#define I_LOG1(s, v)

#define I_LOG2(s, v1, v2)

#define I_LOG8(a)

#define I_LOG81(s, v)

#define I_LOG82(s, v1, v2)

#endif

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

//

// CImageInfo::CImageInfo

//

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

EXPORT_C CImageInfo* CImageInfo::NewL()

{

	CImageInfo *self = NewLC();

	CleanupStack::Pop();	// self

	return self;

}

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

//

// CImageInfo::CImageInfo

//

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

EXPORT_C CImageInfo* CImageInfo::NewL(const CImageInfo& a)

{

	CImageInfo *self = NewLC(a);

	CleanupStack::Pop();	// self

	return self;

}

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

//

// CImageInfo::CImageInfo

//

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

EXPORT_C CImageInfo* CImageInfo::NewLC()

{

	CImageInfo *self = new (ELeave) CImageInfo();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

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

//

// CImageInfo::CImageInfo

//

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

EXPORT_C CImageInfo* CImageInfo::NewLC(const CImageInfo& a)

{

	CImageInfo *self = new (ELeave) CImageInfo(a);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

}

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

//

// CImageInfo::CImageInfo

//

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

EXPORT_C void CImageInfo::ConstructL()

{

}

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

//

// CImageInfo::CImageInfo

//

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

EXPORT_C CImageInfo::CImageInfo() :

	iUri(KNullDesC8()),

	iEncoded(EFalse),

	iFilePath(KNullDesC8()),

	iId(KErrNotFound),

	iCopies(1),

	iIndex(KErrNotFound)

{

}

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

//

// CImageInfo::CImageInfo

//

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

EXPORT_C CImageInfo::CImageInfo(const CImageInfo &a) :

	iUri(a.iUri),

	iEncoded(a.iEncoded),

	iFilePath(a.iFilePath),

	iId(a.iId),

	iCopies(a.iCopies),

	iIndex(a.iIndex)

{

}

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

//

// CImageInfo::CImageInfo

//

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

EXPORT_C CImageInfo::~CImageInfo()

{

}

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

//

// CImageInfo::UriLog

//

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

EXPORT_C void CImageInfo::UriLog(const TDesC8& aUri)

{

#ifdef ENABLE_LOGGING

	TFileName8 uri;

    UriLog(aUri, uri);

    LOG81("[CImageInfo::UriLog]\t \"%S\"", &uri);

#else // prevent warning in compiler

	aUri.Length();

#endif

}

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

//

// CImageInfo::UriLog

//

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

EXPORT_C void CImageInfo::UriLog(const TDesC& aUri)

{

#ifdef ENABLE_LOGGING

	TFileName uri;

    UriLog(aUri, uri);

    LOG1("[CImageInfo::UriLog(const TDesC&)]\t \"%S\"", &uri);

#else // prevent warning in compiler

	aUri.Length();

#endif

}

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

//

// CImageInfo::UriLog

//

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

EXPORT_C void CImageInfo::UriLog(const TDesC8& aUri, TDes8& aConvert)

{

#ifdef ENABLE_LOGGING

    I_LOG2("[CImageInfo::UriLog(const TDesC8&, TDes8&)]\t %d - %d", aConvert.MaxLength(), aUri.Length());

	if(aUri.Length() >= aConvert.MaxLength())

	{

    	aConvert.Copy(aUri.Left(aConvert.MaxLength()));

	}

	else

	{

		aConvert.Copy(aUri);

	}

	TInt pos = aConvert.Find(KPros8());

	while(pos != KErrNotFound)

	{

		if(KErrNotFound != pos && pos < aConvert.Length())

			aConvert.Replace(pos, KPros8().Length(), KUnderScore8());

		pos = aConvert.Find(KPros8());

	}

#else // prevent warning in compiler

	aUri.Length();

	aConvert.Length();

#endif

}

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

//

// CImageInfo::UriLog

//

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

EXPORT_C void CImageInfo::UriLog(const TDesC& aUri, TDes& aConvert)

{

#ifdef ENABLE_LOGGING

    I_LOG2("[CImageInfo::UriLog(const TDesC&, TDes&)]\t %d - %d", aConvert.MaxLength(), aUri.Length());

	if(aUri.Length() >= aConvert.MaxLength())

	{

    	aConvert.Copy(aUri.Left(aConvert.MaxLength()));

	}

	else

	{

		aConvert.Copy(aUri);

	}

	TInt pos = aConvert.Find(KPros());

	while(pos != KErrNotFound)

	{

		if(KErrNotFound != pos && pos < aConvert.Length())

			aConvert.Replace(pos, KPros().Length(), KUnderScore());

		pos = aConvert.Find(KPros());

	}

#else // prevent warning in compiler

	aUri.Length();

	aConvert.Length();

#endif

}

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

//

// CImageInfo::ConvertL

//

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

EXPORT_C void CImageInfo::ConvertToUTF8L(const TDesC& aSource, TDes8& aResult)

{

	HBufC8* buf = EscapeUtils::ConvertFromUnicodeToUtf8L(aSource);

	if(buf)

	{

	    I_LOG2("[CImageInfo::ConvertToUTF8L]\t %d - %d", aResult.MaxLength(), buf->Des().Length());

		aResult.Copy(buf->Des());

		delete buf;

	}

}

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

//

// CImageInfo::ConvertL

//

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

EXPORT_C void CImageInfo::ConvertToUnicodeL(const TDesC8& aSource, TDes& aResult)

{

	HBufC16* buf = EscapeUtils::ConvertToUnicodeFromUtf8L(aSource);

	if(buf)

	{

	    I_LOG2("[CImageInfo::ConvertToUnicodeL]\t %d - %d", aResult.MaxLength(), buf->Des().Length());

		aResult.Copy(buf->Des());

		delete buf;

	}

}

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

//

// CImageInfo::EncodeUriL

//

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

EXPORT_C void CImageInfo::EncodeUriL(const TDesC8& aDecodedUri, TDes8& aEncodedUri)

{

    TFileName unicodeUri;

    ConvertToUnicodeL( aDecodedUri, unicodeUri );

    EncodeUriL(unicodeUri, aEncodedUri);

}

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

//

// CImageInfo::EncodeUriL

//

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

EXPORT_C void CImageInfo::EncodeUriL(const TDesC16& aDecodedUri, TDes8& aEncodedUri)

{

    I_LOG("[CImageInfo::EncodeUriL]");

    CUri8* uri8 = UriUtils::CreateUriL( aDecodedUri );

    CleanupStack::PushL( uri8 );

    HBufC16* uriBuf = uri8->Uri().DisplayFormL();

    CleanupStack::PushL( uriBuf );

    //alloc enough memory: encoding replaces one char with three: '%XX'

    HBufC8* uriBuf8 = HBufC8::NewLC(KMaxFileName*3);

   	TPtr8 buf8Ptr(uriBuf8->Des());

    ConvertToUTF8L( uriBuf->Des(), buf8Ptr );

    I_LOG("[CImageInfo::EncodeUriL]\t <-ConvertToUTF8L");

    // encode additionally the following characters

    //";"  | "?"  | "@" | "&" | "=" | "+" | "$" | ","

    // no encoding of "/" or ":" for paths

	TInt pos = buf8Ptr.LocateReverse('/');

    I_LOG1("[CImageInfo::EncodeUriL]\t pos %d", pos);

    if(KErrNotFound != pos)

    {

		TPtr8 namePtr(buf8Ptr.LeftTPtr(pos));

	    I_LOG1("[CImageInfo::EncodeUriL]\t namePtr.Length() %d", namePtr.Length());

	    UriLog(namePtr);

	    I_LOG("[CImageInfo::EncodeUriL]\t ->EncodeFileNameL");

	    EncodeFileNameL(namePtr);

    }

    if(buf8Ptr.Length() > aEncodedUri.MaxLength())

    	User::Leave(KErrOverflow);

    aEncodedUri.Copy(buf8Ptr);

    I_LOG("[CImageInfo::EncodeUriL]\t aEncodedUri:");

    UriLog(aEncodedUri);

    CleanupStack::PopAndDestroy( uriBuf8 );

    CleanupStack::PopAndDestroy( uriBuf );

    CleanupStack::PopAndDestroy( uri8 );

}

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

//

// CImageInfo::SetUri

//

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

EXPORT_C void CImageInfo::SetUri(const TDesC8& aUri, const TBool aEncoded)

{

	iUri.Copy(aUri);

	iEncoded = aEncoded;

}

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

//

// CImageInfo::SetUri

//

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

EXPORT_C void CImageInfo::SetUriL(const TDesC& aUri)

{

	ConvertToUTF8L(aUri, iUri);

}

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

//

// CImageInfo::GetUri

//

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

EXPORT_C void CImageInfo::GetUri(TDes8& aUri) const

{

	aUri.Copy(iUri);

}

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

//

// CImageInfo::GetUri

//

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

EXPORT_C void CImageInfo::GetUriL(TDes& aUri) const

{

	ConvertToUnicodeL( iUri, aUri );

}

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

//

// CImageInfo::GetUri

//

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

EXPORT_C void CImageInfo::GetEncodedUriL(TDes8& aUri)

{

    I_LOG1("[CImageInfo::EncodeUriL]\t iEncoded = %d", iEncoded);

	if(iEncoded)

		GetUri(aUri);

	else

		EncodeUriL(iUri, aUri);

}

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

//

// CImageInfo::CompareUri

//

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

EXPORT_C TBool CImageInfo::CompareUri(const TDesC& aUri)

{

	if(KNullDesC() == aUri && KNullDesC8() == iUri)

		return ETrue;

	TFileName8 tmpUri8;

	//First try copy (if earlier copied 8->16 the conversion cannot be done anymore):

	tmpUri8.Copy(aUri);

	if(CompareUri(tmpUri8))

		return ETrue;

	//Then convert:

	TRAPD(err, ConvertToUTF8L(aUri, tmpUri8));

	if(KErrNone == err)

		return CompareUri(tmpUri8);

	return EFalse;

}

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

//

// CImageInfo::CompareUri

//

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

EXPORT_C TBool CImageInfo::CompareUri(const TDesC8& aUri)

{

	if(0 == iUri.Compare(aUri))

		return ETrue;

	TFileName8 encodedUri;

	TRAPD(err, EncodeUriL(iUri, encodedUri));

	if(KErrNone == err && 0 == encodedUri.Compare(aUri))

		return ETrue;

	return EFalse;

}

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

//

// CImageInfo::SetUri

//

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

EXPORT_C void CImageInfo::SetFilePath(const TDesC8& aFilePath)

{

	iFilePath = aFilePath;

}

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

//

// CImageInfo::SetUri

//

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

EXPORT_C void CImageInfo::SetFilePathL(const TDesC& aFilePath)

{

	ConvertToUTF8L(aFilePath, iFilePath);

}

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

//

// CImageInfo::SetUri

//

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

EXPORT_C void CImageInfo::GetFilePath(TDes8& aFilePath) const

{

	aFilePath.Copy(iFilePath);

}

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

//

// CImageInfo::SetUri

//

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

EXPORT_C void CImageInfo::GetFilePathL(TDes& aFilePath) const

{

	ConvertToUnicodeL(iFilePath, aFilePath);

}

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

//

// CImageInfo::CompareFilePath

//

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

EXPORT_C TBool CImageInfo::CompareFilePath(const TDesC& aFilePath)

{

	if(KNullDesC() == aFilePath && KNullDesC8() == iFilePath)

		return ETrue;

	TFileName8 tmpFile8;

	TRAPD(err, ConvertToUTF8L(aFilePath, tmpFile8));

	if(KErrNone == err)

		return CompareFilePath(tmpFile8);

	return EFalse;

}

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

//

// CImageInfo::CompareFilePath

//

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

EXPORT_C TBool CImageInfo::CompareFilePath(const TDesC8& aFilePath)

{

	if(0 == iFilePath.Compare(aFilePath))

		return ETrue;

	return EFalse;

}

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

//

// CImageInfo::SetUri

//

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

EXPORT_C void CImageInfo::SetId(const TInt aId)

{

	iId = aId;

}