/*
* 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
 *
*/


#include "SVGGradientElementImpl.h"
#include "SVGDocumentImpl.h"

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgGradientElementImpl::CSvgGradientElementImpl( CSvgDocumentImpl* aDoc )
	{
	SetOwnerDocument(aDoc);
	}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgGradientElementImpl::ConstructL(const TUint8 aElemID)
	{
    CSvgElementImpl::InitializeL( aElemID );

    iSvgStyleProperties = new(ELeave) RPointerArray<CCssValue>(KCSS_MAX_ATTR);
    User::LeaveIfError( iSvgStyleProperties->Append( NULL ) );
    iSvgStyleProperties->Remove( 0 );
	iSvgUriReferenceImpl = CSvgUriReferenceImpl::NewL();

    iSvgTransformable = CSvgTransformableImpl::NewL();
    iSvgStopElementArray = new( ELeave ) RPointerArray<CSvgStopElementImpl> ( 1 );

    iStopElementData = new(ELeave) RArray<TSvgStopData> (1);
    iStopElementData->Reset();
	}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgGradientElementImpl::~CSvgGradientElementImpl()
    {
    if(iSvgStopElementArray)
		{
        iSvgStopElementArray->Close();
        delete iSvgStopElementArray;
		iSvgStopElementArray = NULL;
		}

	if ( iSvgStyleProperties )
		{
		iSvgStyleProperties->Close();
		delete iSvgStyleProperties;
		iSvgStyleProperties = NULL;
		}

	if ( iSvgUriReferenceImpl )
		{
		delete iSvgUriReferenceImpl;
		iSvgUriReferenceImpl = NULL;
		}

	if(iStopElementData)
		{
		iStopElementData->Close();
		delete iStopElementData;
		iStopElementData = NULL;
		}
	}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CSvgGradientElementImpl::SetAttributeL( const TDesC& aName,const TDesC& aValue )
	{
	CSvgElementImpl::SetAttributeL(aName,aValue);

    if(aName==_L("gradientUnits")||aName==_L("patternUnits"))
		{
        if(aValue==_L("userSpaceOnUse"))
            iGradientPaint->iGradientUnits = KuserSpaceOnUse;
        else if(aValue==_L("objectBoundingBox"))
            iGradientPaint->iGradientUnits = KobjectBoundingBox;
		}
    else if(aName==_L("spreadMethod"))
		{
        if(aValue==_L("pad"))
			iGradientPaint->iSpreadMethod = KspreadMethodPad;
        else if(aValue==_L("reflect"))
			iGradientPaint->iSpreadMethod = KspreadMethodReflect;
        else if(aValue==_L("repeat"))
			iGradientPaint->iSpreadMethod = KspreadMethodRepeat;
		}
	return KErrNone;
	}

TInt CSvgGradientElementImpl::SetAttributeIntL( const TInt aNameId,
                                        const TInt32 aValue )
{
	if(aNameId == KAtrSpreadMethods)
	{

			iGradientPaint->iSpreadMethod = (TUint16) aValue;
	}

	else if(aNameId == KAtrGradientUnits)
		{
		iGradientPaint->iGradientUnits = (TUint16) aValue;
		}

	else
		CSvgElementImpl::SetAttributeIntL (aNameId,aValue);
	return 0;
}
TInt CSvgGradientElementImpl::GetAttributeIntL( const TInt aNameId, TInt32& aValue )
{
	if(aNameId == KAtrSpreadMethods)
	{
		aValue = iGradientPaint->iSpreadMethod ;
	}

	else if(aNameId == KAtrGradientUnits)
		{
		aValue = iGradientPaint->iGradientUnits ;
		}

	else
		CSvgElementImpl::GetAttributeIntL (aNameId,aValue);
	return 0;
}

// ---------------------------------------------------------------------------
// Adjusts the offset values of all the previously added elements such that
// each gradient offset value is greater than the previous gradient stop's
// offset value.
// ---------------------------------------------------------------------------
void CSvgGradientElementImpl::UpdateOffsetValues(CSvgStopElementImpl *aStopEl)
{
    TInt count = iSvgStopElementArray->Count();
    
    if (count == 1)
        {
    	return;
        }
    
    TFloatFixPt aNewOffset = aStopEl->iOffset;
    
    //Since the Stop Element is already added, The loop runs for "count - 1" times.
    for (TInt i=0; i < count - 1; i++)
	     {
		 TFloatFixPt OldOffset = iSvgStopElementArray->operator[](i)->iOffset;
		
		 if ( OldOffset >= aNewOffset )
		     {
		     //set this latter value up so it has at least as high a value as the
			 //previous stop offsets
			 aStopEl->iOffset = OldOffset;
			 
			 if (aStopEl->iOffset == TFloatFixPt(0))
				 {
				 aStopEl->iOffset += TFloatFixPt(.001f);
				 }
				else
				 {
				 //two stop offsets have the same value now so make the one before ever so slightly less
				 //the latter one will control the "overlap point"
				 OldOffset -= TFloatFixPt(.001f);
				 }
				
			 iSvgStopElementArray->operator[](i)->iOffset = OldOffset;
		     }
	     }
    	
}

// ---------------------------------------------------------------------------
// The function not only adds the element in Stop element array but also
// adjusts the offset values of all the previously added elements such that
// each gradient offset value is greater than the previous gradient stop's
// offset value.
// ---------------------------------------------------------------------------
void CSvgGradientElementImpl::AddStopElementInArray(CSvgStopElementImpl *aStopEl)
	{
	
	TBool lFound = EFalse;
	
	TInt err = iSvgStopElementArray->Find(aStopEl);
	
	if( err != KErrNotFound )
	   {
	   lFound = ETrue;
	   }
		
	if(!lFound)
	   {
	   iSvgStopElementArray->Append(aStopEl);
	   UpdateOffsetValues(aStopEl);
	   }
	
	}

void CSvgGradientElementImpl::SetGradientTransMatrix(SVGReal aMatrix[2][3])
	{
	TGfxAffineTransform tempTransform;
    MSvgTransformList*  trList;
    GetTransform( trList );
    TGfxAffineTransform originalTransform   = trList->GetItem( 0 );
    tempTransform.iM00.iValue = aMatrix[0][0];
    tempTransform.iM01.iValue = aMatrix[0][1];
    tempTransform.iM02.iValue = aMatrix[0][2];
    tempTransform.iM10.iValue = aMatrix[1][0];
    tempTransform.iM11.iValue = aMatrix[1][1];
	tempTransform.iM12.iValue = aMatrix[1][2];

    TUint32 lTransType = KTransformIdentity;

    TFloatFixPt KZero;
    TFloatFixPt KOne( KFloatFixOne );
    if ( tempTransform.iM02 != KZero || tempTransform.iM12 != KZero )
        lTransType |= KTransformTranslate;

    if ( tempTransform.iM00 != KZero || tempTransform.iM11 != KZero )
        lTransType |= KTransformScale;

    if ( tempTransform.iM01 != KZero || tempTransform.iM10 != KZero )
        lTransType |= KTransformShear;

    if ( (int)lTransType == KTransformScale &&
                    tempTransform.iM00 == KOne && tempTransform.iM11 == KOne )
         lTransType = KTransformIdentity;

	tempTransform.iTransType = lTransType;

    originalTransform.Concatenate( tempTransform );
    trList->ReplaceItem( originalTransform, 0 );
	}