/*

* Copyright (c) 2003 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:  SVG Implementation source file

 *

*/

#if !defined(__E32BASE_H__)

#include <e32base.h>

#endif

#include "SVGImageElementImpl.h"

#include "SVGDocumentImpl.h"

#include "SVGEngineImpl.h"

#include "SVGSchemaData.h"

#include "GfxAffineTransform.h"

#include <imcvcodc.h>

const TInt  KErrNoAttributeSet  = -1;

#define KSVGWAITFORIMAGEDOWNLOAD 1

#define PERIODIC_DELAY    300000

#define PERIODIC_INTERVAL 1000000

_LIT( KSvg,  ".svg" );

_LIT( KSvgb, ".svgb" );

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

//

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

CSvgImageElementImpl* CSvgImageElementImpl::NewL(  const TUint8 aElemID,

                                                  CSvgDocumentImpl* aDoc )

    {

    CSvgImageElementImpl*   self    = new ( ELeave )

                                      CSvgImageElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID, aDoc );

    CleanupStack::Pop();

    return self;

    }

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

//

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

CSvgImageElementImpl* CSvgImageElementImpl::NewLC(  const TUint8 aElemID,

                                                   CSvgDocumentImpl* aDoc )

    {

    CSvgImageElementImpl*   self    = new ( ELeave )

                                      CSvgImageElementImpl( aDoc );

    CleanupStack::PushL( self );

    self->ConstructL(  aElemID,aDoc );

    return self;

    }

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

//

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

void CSvgImageElementImpl::ConstructL(  const TUint8 aElemID,

                                       CSvgDocumentImpl* /* aDoc */ )

    {

    CSvgElementImpl::InitializeL(  aElemID );

    iUsedImage = EFalse;

//    iBitmap = new ( ELeave ) CFbsBitmap();

    iReqAttrFlag=KSVG_IMAGE_ELEMFLAG;

    iSvgStyleProperties = new(ELeave) RPointerArray<CCssValue>(KCSS_MAX_ATTR);

    User::LeaveIfError( iSvgStyleProperties->Append( NULL ) );

    iSvgStyleProperties->Remove( 0 );

    iSvgTransformable = CSvgTransformableImpl::NewL();

    iSvgUriReferenceImpl = CSvgUriReferenceImpl::NewL();

    iBitmapLoadCalled = EFalse;

    iImgRect.iHeight = TFloatFixPt(-1);

    iImgRect.iWidth = TFloatFixPt(-1);

    iIsBase64 = EFalse;

    }

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

//

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

CSvgImageElementImpl::~CSvgImageElementImpl()

    {

    // Reset the notifiers first.

    NotifyResetReference();

    // Check whether there this element refers to an image element.

    // This would be the case when use is used to refer to a parent 

    // image element.

    if ( iRefElement )

        {

        iRefElement->RemoveImageElementListener( this );

        iRefElement = NULL;

        }

    if ( iImageLoader )

        {

        delete iImageLoader;

        iImageLoader = NULL;

        }

    if ( !iUsedImage )

        {

        delete iBitmap;

        delete iMask;

        }

    if ( !iUsedImage && iPar )

        {

        if ( iPar )

            {

            delete iPar;

            iPar = NULL;

            }

        }

    if ( iImageData )

        {

        delete iImageData;

        iImageData = NULL;

        }

    if ( iSvgUriReferenceImpl )

        {

        delete iSvgUriReferenceImpl;

        iSvgUriReferenceImpl = NULL;

        }

    if ( iSvgStyleProperties )

        {

        iSvgStyleProperties->Close();

        delete iSvgStyleProperties;

        iSvgStyleProperties = NULL;

        }

    iImageElementListeners.Close();

    if ( iSessionConnected )

        {

        iSession.Close();

        }

    }

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

//

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

void CSvgImageElementImpl::GetBBox( TGfxRectangle2D& aBbox )

    {

    iImgRect.GetBounds( GetCTM(), aBbox );

    }

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

//

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

void CSvgImageElementImpl::GetUnscaledBBox( TGfxRectangle2D& aBbox )

    {

    TGfxAffineTransform identityTx;

    iImgRect.GetBounds( identityTx, aBbox );

    }

// *******************************************************

// From SVG DOM

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

//

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

TFloatFixPt CSvgImageElementImpl::X()

    {

    return iImgRect.iX;

    }

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

//

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

TFloatFixPt CSvgImageElementImpl::Y()

    {

    return iImgRect.iY;

    }

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

//

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

TFloatFixPt CSvgImageElementImpl::Width()

    {

    	if (iImgRect.iWidth == TFloatFixPt(-1))

    	{

    		return TFloatFixPt(0);

    	}

    	return iImgRect.iWidth;

    }

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

//

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

TFloatFixPt CSvgImageElementImpl::Height()

    {

    	if (iImgRect.iHeight == TFloatFixPt(-1) )

    	{

    		return TFloatFixPt(0);

    	}

    	return iImgRect.iHeight;

    }

// *******************************************************

// SVG Implementation

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

//

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

void CSvgImageElementImpl::SetWidth( TFloatFixPt aWidth )

    {

    iRenderImage = !(aWidth <= TFloatFixPt(0));

    iImgRect.iWidth = aWidth;

    }

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

//

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

void CSvgImageElementImpl::SetHeight( TFloatFixPt aHeight )

    {

    iRenderImage = !(aHeight <= TFloatFixPt(0));

    iImgRect.iHeight = aHeight;

    }

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

//

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

void CSvgImageElementImpl::SetParL( const TDesC& aName )

    {

    iPar = aName.AllocL();

    }

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

//

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

const TDesC& CSvgImageElementImpl::Par()

    {

    if ( iPar )

        return *iPar;

    else

        return KNullDesC;

    }

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

//

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

void CSvgImageElementImpl::SetUriL( const TDesC& aUri )

    {

    // Indicate that the Uri is set. This is used to decide whether 

    // to indicate an error if xlink:href attribute was not specified

    // on the image element.

    iIsUriSet = ETrue;

    _LIT( KXlinkHref, "xlink:href" );

    SetXlinkAttributeL(KXlinkHref, aUri);

    CheckRequiredAttributes();

	if ( Href().Length() == 0)

	{

		//empty URI string...do nothing

		//JSR 226 tests start out with empty string

		return;

	}

	//We have to be careful in this method searching the entire string

	//because we can get the entire

	//base64 encoded image coming through this call

    // Verify xlink for JavaInterface

    CSvgDocumentImpl* document = (CSvgDocumentImpl*)OwnerDocument();

    //if ( document && aUri.Length() > 0)

    if ( document )

        {

        // Check for local URI (#uri)

        //if ( aUri.Locate( '#' ) != KErrNotFound || aUri.Length() == 0)

          if ( Href().Left(1) == _L("#") )

            {

            document->SetError( KErrNotFound, _L( "Usage of local URI in <image>: " ), aUri );

            }

          else

            {

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

            _LIT( KData, "data:");

            if ( ( Href().Length() >= 7 ) && ( Href().Left( 7 ) == KHttp ) )

                {

                //using an http address for the image

                return;

                }

            else if ( ( Href().Length() >= 5 ) && ( Href().Left( 5 ) == KData ) )

            	{

            	//this is a base 64 image

            	iIsBase64 = ETrue;

            	return;

            	}

            else

                {

                _LIT( KJpgFile, ".jpg");

                _LIT( KPngFile, ".png");

                _LIT( KSvgFile, ".svg");

                // Check for relative URI

          		if ( aUri.Locate( '/' ) == KErrNotFound)

          		{

          			//plain image used...but is this relative?!?

          			//does JSR 226 need an error thrown on this?

          			//i.e. image.jpg

          			if (aUri.Right(4) == KJpgFile)

          			{

          				//this is a plain image.jpg

          				return;

          			}

          			else if (aUri.Right(4) == KPngFile)

          			{

          				//this is a plain image.png file

          				return;

          			}

          			else if (aUri.Right(4) == KSvgFile)

          			{

          				//this is a filename.svg file

          				document->SetError(KErrNotFound, _L("Usage of SVG file in xlink-href:"), aUri);

          			}

          			return;

          		}

                /*if ( aUri.Find( KFile ) != 1 || !TChar( aUri[0] ).IsAlpha() )

                    {

                    document->SetError( KErrNotFound, _L( "Usage of relative URI in <image>: " ), aUri );

                    }

                else

                	{

                		//this is an absolute image

                		//i.e. c:/folder/image.jpg

                	}*/

                }

            }

        }

    }

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

//

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

void CSvgImageElementImpl::LoadUriL()

    {

    if ( Href().Length() == 0 )

        {

        #ifdef _DEBUG

        RDebug::Printf("CSvgImageElementImpl::LoadUriL()--iUri is NULL or empty.");

        #endif

        return;

        }

    iBitmapLoadCalled = ETrue;

    iSessionConnected = EFalse;

    // Cannot continue without SvgEngine instance or

    // MSvgRequestObserver is not set

    CSvgDocumentImpl* document = (CSvgDocumentImpl*)OwnerDocument();

    if ( document == NULL )

        {

        #ifdef _DEBUG

        RDebug::Printf("CSvgImageElementImpl::LoadUriL--document handle null");

        #endif

        return;

        }

    // Request

    if ( ( Href().Length() >= 4 && Href().Right( 4 ) == KSvg ) ||

         ( Href().Length() >= 5 && Href().Right( 5 ) == KSvgb ) )

        {

        iIsSvgFile = ETrue;

        }

    // Don't call LoadUriL if LoadingListener exists and LoadingListener::WillAssignImageData returns ETrue

    if ( document )

        {

        const RPointerArray<MSvgLoadingListener>* listeners = document->GetLoadingListeners();

        if ( listeners && listeners->Count() > 0 )

            {

            if ( (*listeners)[0]->WillAssignImageData() )

                {

                (*listeners)[0]->ImageDataReference( Href() );

                return;

                }

            }

        }

    // Embedded image

    if ( ( Href().Length() >= 5 ) && ( Href().Left( 5 ) == _L( "data:" ) ) )

        {

        ProcessEncodedImageL( Href() );

        return;

        }

    iBitmapOrgReady = EFalse;

    iBitmapReady = EFalse;

    CSvgEngineImpl* engine  = document->Engine();

    if ( engine == NULL || engine->iRequestObserver == NULL )

        {

        #ifdef _DEBUG

        RDebug::Printf("CSvgImageElementImpl::LoadUriL--engine handle null");

        #endif

        return;

        }

    // Connect session

    RFile fileHandle;

    if ( iSession.Connect() != KErrNone )

        {

        return;

        }

    iSessionConnected = ETrue;

    TInt status = engine->iRequestObserver->FetchImage( Href(), iSession, fileHandle );

    if ( status == KErrNone )

        {

        // prevent division by zero (DrawL) when image fails to load

        CFbsBitmap* aBitmap = new ( ELeave ) CFbsBitmap();

        CleanupStack::PushL( aBitmap );

        TInt lCreateErr = aBitmap->Create( TSize( 1, 1 ), EColor64K );

        if ( lCreateErr != KErrNone )

            {

            // Error in creation, destroy the bitmap and return

            CleanupStack::PopAndDestroy( aBitmap );

            return;

            }

        // Ownership is about to be tranferred to Image Element

        CleanupStack::Pop( aBitmap );

        TInt lDecodeErr = StartImageDecoding( fileHandle, aBitmap, ETrue );

        if ( lDecodeErr != KErrNone )

            {

            // No error Processing

            }

        }

    else

        {

        iSession.Close();

        iSessionConnected = EFalse;

        }

    }

void CSvgImageElementImpl::PrepareImageFromSvgFile(const TDesC8& aImageData)

    {

    CSvgDocumentImpl* document = (CSvgDocumentImpl*)OwnerDocument();

    if ( !document )

        {

        return;

        }

    CSvgEngineImpl* engine  = document->Engine();

    if ( !engine )

        {

        return;

        }

    TSize bitmapSize( (TInt32)Width(), (TInt32)Height() );

    if ( !iBitmap )

        {

        iBitmap = new CFbsBitmap();

        }

    if(!iMask)

	    {

		iMask = new CFbsBitmap();        	

	    }

    if(iMask)

        {

		iMask->Create( bitmapSize, EGray256);        	

        }

    // Can't use ELeave because this function can't leave

    // Using ELeave but didn't handle (no trap or propagate to parents) causes more confusing.

    // Check for NULL is good enough.

    // Ignore CodeScanner error (Code Review Guide)

    if (iBitmap)

        {

	    iBitmap->Create( bitmapSize, EColor16MU );

        TBool preserveRatio = !( iPar != NULL && *iPar == _L( "none" ) );

        // RenderFileToBuffer if uri is a svg file

        TInt err = engine->RenderFileToBuffer( aImageData, iBitmap,iMask, preserveRatio );

        ImageLoadingCompleted(err);

        }

    iSession.Close();

    }

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

//

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

void CSvgImageElementImpl::ProcessEncodedImageL( const TDesC& aXlinkHrefValue )

    {

    // find positions for ';' and ',' to determine encoding, mimetype

    TInt startIndex = aXlinkHrefValue.Locate( ';' );

    TInt endIndex = aXlinkHrefValue.Locate( ',' );

    // mimetype is after 'data:' : xlink:href="data:image/png;base64,

    // ignore mimetype extraction, decode will detect mimetype from decoded data.

    if ( startIndex != KErrNotFound && endIndex != KErrNotFound &&

         startIndex < endIndex )

        {