/*

* Copyright (c) 2005 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:  This file implements the read codec for the SVG presentation

*

*/

#include "SVGCodec.h"

// INCLUDE FILES

#include <uri16.h>

#include <coeutils.h>

#include <SVGEngineInterfaceImpl.h>

#include <gdi.h>

#include <pathconfiguration.hrh>

// User Includes

#include <SVGTUIControlDbgFlags.hrh>

#include <imcvcodc.h>

#include <utf.h>

#ifdef RD_MULTIPLE_DRIVE    

#include <pathinfo.h>

#include <driveinfo.h>

#endif

// General Constants

const TInt KSccConstZero = 0;

const TUint KSccBackground = 0xffffffff;

// SMIL Fit Value

_LIT( KSccSmilFitValue,"meet" );

//

_LIT( KWww, "www" );

_LIT( KHttp, "http://");

_LIT( KDotDot, ".." );

_LIT( KBSlashStr, "/" );

_LIT( KSlashStr, "\\" );

_LIT( KDotSlashStr, ".\\" );

_LIT( KColonStr, ":" );

_LIT(KJpg,   ".jpg" );

_LIT(KJpeg,  ".jpeg" );

_LIT(KPng,   ".png" );

_LIT(KBmp,   ".bmp" );

_LIT(KSvg,   ".svg" );

_LIT(KSvgz,  ".svgz" );

//

enum TSVGCodecPanic

    {

    ECouldNotGenerateThumbnail

    };

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

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

// CSvgReadCodec::CSvgReadCodec

// Default constructor. 

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

//

CSvgReadCodec::CSvgReadCodec( const TSize& aSize ): iImagesPresent(EFalse),

                                                    iImagesLoaded (EFalse),

                                                    iOriginalSize(aSize)

    {

    }

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

// CSvgReadCodec::NewL

// Static constructor. Returns the pointer to the CSvgReadCodec

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

//

CSvgReadCodec* CSvgReadCodec::NewL( const TSize& aSize )

    {

    CSvgReadCodec* self = new(ELeave) CSvgReadCodec( aSize );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self); 

    return self;

    }

void CSvgReadCodec::ConstructL()

    {

    iSvgModule = NULL;

    iSVGTBitMapDummy = NULL;

    InitializeEngineL();

    }

void CSvgReadCodec::InitializeEngineL()

    {

    if ( !iSvgModule )

       {

       TFontSpec spec;

       if ( !iSVGTBitMapDummy )

           {

           // For thumbnails, the user provided bitmap is used,

           // Have to give some dummy bitmap to the engine in the constructor.

           iSVGTBitMapDummy  = new( ELeave ) CFbsBitmap;

           User::LeaveIfError( 

                iSVGTBitMapDummy->Create( 

                    TSize( KSccConstZero, KSccConstZero ), 

                    EGray2 ) );

           }

       iSvgModule = CSvgEngineInterfaceImpl::NewL( iSVGTBitMapDummy, this, spec );

// 0xffffffff is the default color.

       iSvgModule->SetBackgroundColor( KSccBackground );

       iSvgModule->AddListener(static_cast<MSvgLoadingListener*>(this),

            ESvgLoadingListener);

       }

    }

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

// CSvgReadCodec::~CSvgReadCodec

// Destructor

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

//

CSvgReadCodec::~CSvgReadCodec()

    {

    DeleteEngine();

    // Dummy bitmap

    delete iSVGTBitMapDummy;

    // SVG file data

    delete iFileData;

    }

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

// CSvgReadCodec::SetFileDataL

// Sets the SVG presentation data

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

//

void CSvgReadCodec::SetFileDataL( const TDesC8& aFileData )

    {

    delete iFileData;

    iFileData = NULL;

   	// For files which are in UTF-16 or unicode format the first 2 bytes

	// will be FF and FE. In UTF-16 and unicode format every single character

	// is represented by two bytes. 

    HBufC8* binaryBuffer=NULL;

  	binaryBuffer = HBufC8::NewL( aFileData.Length() ); 

  	TPtr8 binaryBufferPtr = binaryBuffer->Des();

	binaryBufferPtr = aFileData;

	TInt hichar = (CEditableText::EReversedByteOrderMark & 0xFF00)>>8;

	TInt lochar = CEditableText::EReversedByteOrderMark & 0x00FF;

	TInt bytesPerChar = 1;

    if(binaryBufferPtr[0] == hichar && binaryBufferPtr[1] == lochar)

    	{

    	bytesPerChar = 2;

    	HBufC* dataBuffer=NULL;

        TInt fileSize = aFileData.Length();

    	dataBuffer = HBufC::New(aFileData.Length()/bytesPerChar);

    	if ( !dataBuffer)

    		{

        	//_LIT( KErrorMsg, "Failed to Load Svg Content: Out of memory");

        	delete binaryBuffer;

        	return;

    		}

    	TPtr dataBufferPtr = dataBuffer->Des();

    	// Skip two bytes and set the pointer to the next location

    	// from where the actual data starts.

    	dataBufferPtr.Set((TUint16*)binaryBufferPtr.Ptr()+1,

    						fileSize/bytesPerChar-1, 

    						fileSize/bytesPerChar-1);

    	HBufC8* outputBuffer= NULL;

    	outputBuffer=HBufC8::New(fileSize);

    	if(!outputBuffer)

    		{

    		//_LIT( KErrorMsg, "Failed to Load Svg Content: Out of memory");

        	delete dataBuffer;

        	delete binaryBuffer;

        	return ;

    		}

    	TPtr8 outputBufferptr=outputBuffer->Des();

    	CnvUtfConverter::ConvertFromUnicodeToUtf8(

            							outputBufferptr,   // Destination

            							dataBufferPtr );

        iFileData = HBufC8::NewL(fileSize);

        iFileData->Des().Copy(outputBufferptr);

        delete dataBuffer;

        delete outputBuffer;

    	}

    else

        {

        iFileData = HBufC8::NewL(aFileData.Length());

        iFileData->Des().Copy( aFileData );

        }

        delete binaryBuffer;

    }

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

// CSvgReadCodec::ProcessFrameL

// Processes the frame data contained in aSrc.

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

//

TFrameState CSvgReadCodec::ProcessFrameL(TBufPtr8& aSrc )

    {

    aSrc.Shift( 1 );

    TFrameState lRetVal = EFrameComplete;

    DoProcessL();

    if(iImagesPresent && !iImagesLoaded)

        {

        lRetVal = EFrameIncompleteRepositionRequest;

        }

    return lRetVal;

    }

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

// CSvgReadCodec::DoProcessL

// Processes the SVG presentation file data. Called by ProcessFrameL()

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

//

void CSvgReadCodec::DoProcessL()

    {

    }

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

// CSvgReadCodec::InitFrameL

// Processes the SVG presentation file data. Called by ProcessFrameL()

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

//

void CSvgReadCodec::InitFrameL(TFrameInfo& /* aFrameInfo*/, 

    CFrameImageData& /*aFrameImageData*/, 

    TBool /*aDisableErrorDiffusion */, 

    CFbsBitmap& aFrame, 

    CFbsBitmap* /* aDestinationMask */ )

    {

        GenerateThumbnailL(&aFrame, NULL);

    }

void CSvgReadCodec::UpdateScreen()

    {

    }

TBool CSvgReadCodec::ScriptCall( const TDesC& /*aScript*/, CSvgElementImpl* /*aCallerElement*/ )

    {

    return EFalse;

    }

TInt  CSvgReadCodec::FetchImage( const TDesC& aUri, RFs& aSession, RFile& aFileHandle )

    {

    TInt errorCode = KErrNotFound;

    TInt ret = 0;

    TRAPD(err, ret = IsDownloadNeededL(aUri));

    if(err==KErrNone)

        {

        if( ret == ELocalImageFile)

            {

            TFileName fileName;

#ifdef RD_MULTIPLE_DRIVE    

//    RFs fsSession;

            HBufC* fullImagesPathBuf = HBufC::New( KMaxPath );

            if (fullImagesPathBuf)

                {

                TPtr fullImagesPathPtr = fullImagesPathBuf->Des();

                TInt intDrive;

                DriveInfo::TDriveArray driveArray;

//    fsSession.Connect();

                TInt err1=DriveInfo::GetUserVisibleDrives( aSession, driveArray );

                if(err1==KErrNone)

                    {

                    for(TInt i=0; i < driveArray.Count(); i++)

                        {

                        TChar driveLetter = driveArray.LetterAt(i);

                        TInt err2=RFs::CharToDrive(driveLetter, intDrive);

                        if(err2==KErrNone)

                            {

                            TInt err3=PathInfo::GetRootPath(fullImagesPathPtr, intDrive);

                            if(err3==KErrNone)

                                {

                                fullImagesPathPtr.Append( PathInfo::ImagesPath() );

                                if(GetLocalFile( aUri, fileName, fullImagesPathPtr))

                                    {

                                    errorCode = aFileHandle.Open( aSession, fileName, EFileShareAny );

                                    break;

                                    }

                                }

                            }

                        }

                    }

                }

            delete fullImagesPathBuf;

            fullImagesPathBuf=NULL;

//    fsSession.Close();

#else

            HBufC* phoneMemImagesPath = GetImagesPath(EPhoneMemory);

            TPtr ptrphoneMemImagesPath(phoneMemImagesPath->Des());

            HBufC* memCardImagesPath = GetImagesPath(EMemoryCard);

            TPtr ptrMemCardImagesPath(memCardImagesPath->Des());

            if(GetLocalFile( aUri, fileName, ptrphoneMemImagesPath))

                errorCode = aFileHandle.Open( aSession, fileName, EFileShareAny );

            else if(GetLocalFile( aUri, fileName, ptrMemCardImagesPath))

                errorCode = aFileHandle.Open( aSession, fileName, EFileShareAny );

            delete memCardImagesPath;

            delete phoneMemImagesPath;

#endif        

            }

        }

    return errorCode;

}

TInt CSvgReadCodec::FetchFont( const TDesC& /* aUri */, 

                                    RFs& /* aSession */, RFile& /* aFileHandle */ )

    {

    return KErrNotSupported;

    }

void CSvgReadCodec::GetSmilFitValue( TDes& aSmilValue )

    {

    aSmilValue.Copy( KSccSmilFitValue );

    }

void  CSvgReadCodec::UpdatePresentation( const TInt32& /* aNoOfAnimation */ )

    {

    }

void CSvgReadCodec::PrepareEngine()

    {

    iPrepareDomResult = iSvgModule->PrepareDom( *iFileData, iThumbnailHandle );

    TInt err = iPrepareDomResult->HasError();

    iSvgModule->UseDom( iThumbnailHandle, NULL);

    iContentSize = iSvgModule->GetSvgBoundingBox().Size();

    if(iContentSize.iHeight < 1)

        {

        iContentSize.iHeight = 1;

        }

    if(iContentSize.iWidth < 1)

        {

        iContentSize.iWidth = 1;

        }

    }

TSize CSvgReadCodec::ContentSize() const

    {

    return iContentSize;

    }

void CSvgReadCodec::GenerateThumbnailL(CFbsBitmap* aFrame, CFbsBitmap* /*aFrameMask*/)

    {

    if ( iSvgModule )

        {

        // NULL is returned, possible out of memory when create error object.

        User::LeaveIfNull( iPrepareDomResult );

        User::LeaveIfError(iPrepareDomResult->HasError());

#ifdef SVGTUICONTROL_DBG_DRM_THUMBNAIL_API_ENABLE        

        iSvgModule->SetThumbNailMode( ETrue );            // Set thumbnail mode On

#endif // SVGTUICONTROL_DBG_DRM_THUMBNAIL_API_ENABLE

        // Setup the engine to use the DOM

        MSvgError* pResult = iSvgModule->UseDom( iThumbnailHandle, aFrame );

        if ( pResult->HasError() && !pResult->IsWarning() )

            {                

            User::Leave( KErrGeneral );

            }

        // View Box define for Dom associated frame

        iSvgModule->ChooseViewBoxIfNotSet(iThumbnailHandle);

        // Setup the frame size as the one obtained from 

        // creator of codec.

        const TSize frameSize = aFrame->SizeInPixels();

        // Get the Display mode for bitmap

        TDisplayMode lFrameDispMode = aFrame->DisplayMode();

        // Get the Displaymode for mask

            iSvgModule->InitializeEngine();

            iSvgModule->RenderFrame( NULL, 0);

      // render static content as well

       if ( iFrameList.Count() )

            {

            CFbsBitGc* bitmapContext=NULL;

            CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( aFrame );

            CleanupStack::PushL( bitmapDevice );

            User::LeaveIfError( bitmapDevice->CreateContext( bitmapContext ) );

            CleanupStack::PushL( bitmapContext );

            bitmapContext->BitBlt( TPoint(0,0),iFrameList[ 0 ] );

            CleanupStack::PopAndDestroy(2);

            } 

#ifdef SVGTUICONTROL_DBG_DRM_THUMBNAIL_API_ENABLE        

        iSvgModule->SetThumbNailMode( EFalse );       // Set thumbnail mode Off 

#endif // SVGTUICONTROL_DBG_DRM_THUMBNAIL_API_ENABLE

        }

    }

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

// CSvgReadCodec::DeleteEngine

// Deletes the structures associated with the engine

// viz. The Frame List, Mask List, Delay Interval List, 

// The DOM for the content and the Engine Implementation itself

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

//  

void CSvgReadCodec::DeleteEngine()

    {       

    // Cleanup elements in the frame list

    for ( TInt i = 0; i < iFrameList.Count(); i++ )

        {

        delete iFrameList[i];

        }        

    // Cleanup elements in the mask list

    for ( TInt i = 0; i < iMaskList.Count(); i++ )

        {

        delete iMaskList[i];

        }        

    // Cleanup the memory used for storing the pointers/values

    iFrameList.Reset();

    iMaskList.Reset();

    iDelayList.Reset();

    // Close the resources

    iFrameList.Close();

    iMaskList.Close();

    iDelayList.Close();

    // Delete the DOM created for the content    

    //if ( iThumbnailHandle )

    //    {

    //    iSvgModule->DeleteDom( iThumbnailHandle );

    //    iThumbnailHandle = 0;

    //    }

    // Delete the Engine module 

    delete iSvgModule;    

    iSvgModule = NULL;

    }   

CSvgReadCodec::TDownloadNeeded CSvgReadCodec::IsDownloadNeededL( const TDesC& aUri ) const

    {

    TUriParser UriParser;

    TBuf<KMaxFileName> localUri;

    // url starts with www so append http://

    if ( !aUri.Left( 4 ).Compare( KWww ) )     

        {

        localUri.Append( KHttp );

        localUri.Append( aUri );

        User::LeaveIfError( UriParser.Parse( localUri ) );   

        }

    else

        {

        User::LeaveIfError( UriParser.Parse( aUri ) );   

        }

    if ( UriParser.IsPresent( EUriHost ) )

        {

        // Extract the Path, filename and extension from the uri

        TFileName filename = UriParser.Extract( EUriPath ); 

        TParsePtrC fileParser( filename );

        if ( fileParser.NamePresent() && fileParser.ExtPresent() )

            {                        

            if ( fileParser.Ext().Compare( KJpg ) == 0  ||  

                 fileParser.Ext().Compare( KJpeg ) == 0 ||

                 fileParser.Ext().Compare( KBmp ) == 0  ||

                 fileParser.Ext().Compare( KPng ) == 0  ||

                 fileParser.Ext().Compare( KSvg ) == 0  ||

                 fileParser.Ext().Compare( KSvgz ) == 0 )

                {

                // file name and ext present and 

                // it is amy of the supported image types

                return ERemoteImageFile;         

                }

            else

                {

                //file Extension present but not a supported image ext,

                //may be some html file

                return ENotAnImageFile;

                }

            } 

        else

            {

            //Should be a domain name so return ENotAnImageFile

            return ENotAnImageFile;

            }

        }

    else

        {     

        return ELocalImageFile;

        }                        

    }

TBool CSvgReadCodec::GetLocalFile( const TDesC& aUri, 

                                    TDes& aFileName ,

                                    const TDesC& aRefPath ) const

    {

    aFileName.Zero();

    TBuf<KMaxFileName> copyUri = aUri;

    // Before giving the uri to the file parser,