/*

* 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 "GfxAffineTransform.h"

#include "SVGTransformListImpl.h"

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

//

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

CSvgTransformListImpl* CSvgTransformListImpl::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

//

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

CSvgTransformListImpl* CSvgTransformListImpl::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

CSvgTransformListImpl::~CSvgTransformListImpl()

    {

    iTransformations.Close();

    iTransformAdditive.Close();

    iTransformTypes.Close();

    }

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

// From SVG DOM

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

//

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

TBool CSvgTransformListImpl::AppendItemL( TGfxAffineTransform& aTransform )

    {

    iTransformations.AppendL( aTransform );

    iTransformAdditive.AppendL( 2 );  // do nothing if not set Default: additive

    iTransformTypes.AppendL( 0 );  // Default: not animMotion

    iAvoidConsolidation = EFalse;

    return ETrue;

    }

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

//

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

TBool CSvgTransformListImpl::AppendItemL( TGfxAffineTransform& aTransform,

                                          TInt32 aAdditive,

                                          TInt32 aSrcAnimMotion )

    {

    iTransformations.AppendL( aTransform );

    iTransformAdditive.AppendL( aAdditive );

    iTransformTypes.AppendL( aSrcAnimMotion );

    iAvoidConsolidation = EFalse;

    return ETrue;

    }

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

//

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

void CSvgTransformListImpl::Clear()

    {

    iTransformations.Reset();

    iAvoidConsolidation = EFalse;

    }

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

//

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

TGfxAffineTransform CSvgTransformListImpl::Consolidate(TBool aOverwriteTrans)

    {

    if(!iAvoidConsolidation)

    {

    TInt numTransforms = iTransformations.Count();

    TInt i;

    TGfxAffineTransform tr,tr2,tr3;

    TGfxAffineTransform tmpAnimMotion;

    TInt32 tmpAdditive;

    TInt32 tmpAnimType;

    for ( i = 0; i < numTransforms; i++ )

        {

        tmpAdditive = iTransformAdditive[i];

        tmpAnimType = iTransformTypes[i];

        if ( tmpAnimType == 0 )

            {

             tr.Concatenate( iTransformations[i]);

            }

        }

    // first find the animate Motion

    for ( i = numTransforms-1 ; i > -1 ; i-- )

        {

        tmpAdditive = iTransformAdditive[i];

        tmpAnimType = iTransformTypes[i];

        if ( tmpAnimType == 1 && tmpAdditive == 0 )

            {

                {

                // overwrite the previous animTrans transforms,

                // but not the previous animMotion transforms

                //tr = iTransformations[i];

                tr2.Concatenate( iTransformations[i] );

                   //i--;

				break;

                }

            }

        }

        i++;

        for ( ;i < numTransforms; i++ )

        {

            if ( 1 == iTransformTypes[i] )

            {

                /*tmpAnimMotion = iTransformations[i];*/

                tr.Concatenate(tmpAnimMotion);

                tr2.Concatenate( iTransformations[i] );

            }

        }

    for ( i = 0; i < numTransforms; i++ )

        {

        tmpAdditive = iTransformAdditive[i];

        tmpAnimType = iTransformTypes[i];

        if ( tmpAnimType == 2 )

            {

            // if matrix is additive, continue calculation

            if ( !aOverwriteTrans)

                {

                tr3.Concatenate( iTransformations[i] );

                }

            else

                {

                // overwrite the previous animTrans transforms,

                // but not the previous animMotion transforms

                //tr = tmpAnimMotion;

                tr = tmpAnimMotion;

                tr3 = iTransformations[i];

                }

            }

		}

     tr.Concatenate(tr2);

	 tr.Concatenate(tr3);

		 /*Saving Conslidated Matrix for Later use*/

		iConsolidatedMatrix.iM00 = tr.iM00;

		iConsolidatedMatrix.iM01 = tr.iM01;

		iConsolidatedMatrix.iM02 = tr.iM02;

		iConsolidatedMatrix.iM10 = tr.iM10;

		iConsolidatedMatrix.iM11 = tr.iM11;

		iConsolidatedMatrix.iM12 = tr.iM12;

		iConsolidatedMatrix.iTransType = tr.iTransType;

		iAvoidConsolidation = ETrue;

		}

    return iConsolidatedMatrix;

	}

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

//

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

TGfxAffineTransform CSvgTransformListImpl::GetItem( TInt aIndex )

    {

    if(aIndex < iTransformations.Count())

        {

        return iTransformations[aIndex];

        }

    else

        {

    		// what does this means.

    	TGfxAffineTransform a;

    		return a;

    	}

    }

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

//

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

TInt CSvgTransformListImpl::NumberOfItems()

    {

    return iTransformations.Count();

    }

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

//

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

TGfxAffineTransform CSvgTransformListImpl::InitializeL( TGfxAffineTransform& aNewItem )

    {

    iTransformations.Reset();

    iTransformations.AppendL( aNewItem );

    iAvoidConsolidation = EFalse;

    return aNewItem;

    }

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

//

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

TGfxAffineTransform CSvgTransformListImpl::ReplaceItem( TGfxAffineTransform newItem,

                                                        int aIndex )

    {

    if(aIndex < iTransformations.Count())

        {

        iTransformations[ aIndex ] = newItem;

        }

    iAvoidConsolidation = EFalse;

    return newItem;

    }

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

//

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

void CSvgTransformListImpl::SetAdditive( TInt32 additive, TInt32 index )

    {

    iTransformAdditive[ index ] = additive;

    }

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

//

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

CSvgTransformListImpl* CSvgTransformListImpl::CloneL()

    {

    CSvgTransformListImpl* retValue = CSvgTransformListImpl::NewL();

    CleanupStack::PushL(retValue);

    TInt i;

    // copy iTransformations

    retValue->iTransformations.Reset();

    TInt transformationCnt = this->iTransformations.Count();

    for (i=0; i<transformationCnt; i++)

        retValue->iTransformations.AppendL(this->iTransformations[i]);

        {

        }

    // copy iTransformAdditive

    retValue->iTransformAdditive.Reset();

    TInt transformAdditiveCnt = this->iTransformAdditive.Count();

    for (i=0; i<transformAdditiveCnt; i++)

        {

        retValue->iTransformAdditive.AppendL(this->iTransformAdditive[i]);

        }

    // copy iTransformTypes

    retValue->iTransformTypes.Reset();

    TInt transformTypesCnt = this->iTransformTypes.Count();

    for (i=0; i<transformTypesCnt; i++)

        {

        retValue->iTransformTypes.AppendL(this->iTransformTypes[i]);

        }

    CleanupStack::Pop();

    return retValue;

    }

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

// Private

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

//

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

void CSvgTransformListImpl::ConstructL()

    {

    TGfxAffineTransform tr;

    iTransformations.AppendL( tr );

    iTransformAdditive.AppendL( 2 ); // pass

    iTransformTypes.AppendL( 0 );

    }

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

//

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

CSvgTransformListImpl::CSvgTransformListImpl() : iTransformations( 1 ),

                                                 iTransformAdditive( 1 ),

                                                 iTransformTypes( 1 )

    {

    }

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

//

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

void	CSvgTransformListImpl::SetAvoidConsolidation(TBool aAvoidConsolidation)

	{

		iAvoidConsolidation = aAvoidConsolidation;

	}