/*
* 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 "SVGPaintCssValueImpl.h"
#include "SVGFloatCssValueImpl.h"

#include "SVGElementImpl.h"
#include "SVGColor.h"
#include "GfxPaint.h"

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



// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CPaintCssValueImpl::~CPaintCssValueImpl()
    {

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

     if ( iValue && iIsValueOwned )

        {
        delete ( TSvgColor * ) iValue;
        }
     iValue = NULL;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
MGfxPaint* CPaintCssValueImpl::Value()
    {
    CSvgElementImpl* lReferencedElement = NULL;
    if ( iUrlFlag && iSvgElementImpl )
        {
        	// iUrlFlag is true means this paint is gradient.
        	CSvgDocumentImpl *lDoc = (CSvgDocumentImpl *)iSvgElementImpl->OwnerDocument();

        	if (lDoc)
        	{
        		if(iUrlId)
        		{
		        	lReferencedElement = ( CSvgElementImpl*)lDoc->GetElementById( *iUrlId );
		        	if(lReferencedElement)
		        		TInt elementId = lReferencedElement->ElemID();
		        	if ( lReferencedElement && ((lReferencedElement->ElemID() == KSvgLinearGradientElement) ||
		              (lReferencedElement->ElemID() == KSvgRadialGradientElement)) )
		        	{
		         		//Get Attributes from Gradient Element
		        		iValue =  ((CSvgGradientElementImpl *)lReferencedElement)->PaintAttribute();
                        iIsValueOwned = EFalse;
		        	}
		        	else if (lReferencedElement && lReferencedElement->ElemID() == KSvgSolidColorElement )
		        	{
		        		// Get Attributes from solidColor element
		        		GetColorFromSolidColorElement(lReferencedElement);
		        		// delete the reference because we now have a clone.
	   					TRAPD(err, SetValueL(iValue->GetColor()));
		        		delete iUrlId;
		        		iUrlId = NULL;
	   					if (err)
    	   					{
                            #ifdef _DEBUG
                            RDebug::Printf("CPaintCssValueImpl::Value() error trapped=%d", err);
                            #endif
    	   					}
		        		iUrlFlag = EFalse;
  		        	}
  		        	else  // id = color value... for some reason like <rect id="red" fill="red"
  		        		{
						TRAPD(err, SetValueL(iUrlId->Des()));
	   					if (err)
    	   					{
                            #ifdef _DEBUG
                            RDebug::Printf("CPaintCssValueImpl::Value() error trapped=%d", err);
                            #endif
    	   					}
  		        		}
        		}
        	}
        }

    return iValue;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CPaintCssValueImpl::SetValueL( const TDesC& aValue )
    {
    if ( iValue )
        {
        delete ( TSvgColor * ) iValue;
        iValue = NULL;
        iIsValueOwned = EFalse;
        }

    _LIT( KNone, "none" );

    _LIT( KCurrentColor, "currentColor" );
    _LIT(KUrl,"url");


    TUint32 tempVal = 0x000000;//default is 'black'
    if ( aValue == KNone )
        {
        tempVal = KGfxColorNull;
        }
    else if ( aValue == KCurrentColor )
        {
        tempVal = KSvgCurrentColor;
        }
    else if (aValue.Left(3) == KUrl)
        {
        // URL = gradient at the moment...
        iUrlFlag=ETrue;

        HBufC* lReferenceId = (aValue.Right(aValue.Length()-5)).AllocL();


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

        iUrlId = (lReferenceId->Left(lReferenceId->Length()-1)).AllocL();

        delete lReferenceId;
        lReferenceId = NULL;

        // Return it from here otherwise a memory Leak will occur
        return KErrNone;

        }
    else
        {


        TSvgColor tColor(KGfxColorNull);
        if( tColor.GetStringL( aValue,tempVal) != EFalse )
            {
            }
        else
            {
            tempVal = 0;
            iDefaultSet = ETrue;
            }
        }
    iValue = new ( ELeave ) TSvgColor( tempVal );
    iIsValueOwned = ETrue;
    return KErrNone;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CPaintCssValueImpl::SetValueL( const TInt& aValue )
    {
     if ( iValue && !iUrlFlag)
        {
        delete ( TSvgColor * ) iValue;
        iValue = NULL;
        }
		iUrlFlag = EFalse;
    iValue = new ( ELeave ) TSvgColor( aValue );
    iIsValueOwned = ETrue;
    return KErrNone;
    }
// ---------------------------------------------------------------------------
// This method gets the color value from the referenced solidColor element
// ---------------------------------------------------------------------------
void CPaintCssValueImpl::GetColorFromSolidColorElement(CSvgElementImpl* aReferencedElement)
    {
    CCssValue*  lCssValue = NULL;
    aReferencedElement->FindProperty( KCSS_ATTR_FILL, lCssValue, aReferencedElement );
    if (lCssValue != NULL)
       {
       iValue = ((CPaintCssValueImpl*)lCssValue)->Value();
       ((CSvgSolidColorElementImpl*)aReferencedElement)->ApplyOpacitytoElement( iSvgElementImpl );
       }
    }

/*// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CPaintCssValueImpl::SetL( CPaintCssValueImpl* aValue )
{
	iSvgElementImpl = aValue->iSvgElementImpl;
	iValueType = aValue->iValueType;

	if (aValue->iValue && !aValue->iUrlFlag)
	{
		CloneRGBValueL( ((TSvgColor*)(aValue->iValue))->Value());
	}
	else if (aValue->iValue)
	{
		iValue = aValue->iValue;
	}

	iDefaultSet = aValue->iDefaultSet;
	iUrlFlag = aValue->iUrlFlag;

    if( aValue->iUrlFlag )
        {
        SetUrlIdL(aValue->iUrlId->Des());
        }
}
*/

// *******************************************************
// Private


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CPaintCssValueImpl::CPaintCssValueImpl() :iUrlId(NULL), iValue( NULL ),
                                          iUrlFlag(EFalse), 
                                          iDefaultSet (EFalse), 
                                          iIsValueOwned( EFalse )
    {
    }



// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void  CPaintCssValueImpl::SetUrlflag()
    {
    iUrlFlag= ETrue;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool CPaintCssValueImpl::GetUrlflag()
{
    return iUrlFlag;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void  CPaintCssValueImpl::SetUrlIdL(const TDesC& aValue)
    {
    if( iUrlId )
        {
        delete iUrlId;
        iUrlId = NULL;
        }
    iUrlId  = aValue.AllocL();
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CPaintCssValueImpl::CloneRGBValueL(const TInt& aValue)
    {
    if (!iUrlFlag)
        {
        if(iValue)
        	{
        	delete ( TSvgColor * ) iValue;
        	}
   		iValue = new ( ELeave ) TSvgColor( (TUint32)aValue );
   		iIsValueOwned = ETrue;
        }

    return KErrNone;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
HBufC*  CPaintCssValueImpl::GetUrlId()
    {
    return iUrlId;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool CPaintCssValueImpl::IsEqual( CCssValue* aValue )
{
    if (((CPaintCssValueImpl*)aValue)->iValue == iValue)
    {
        return ETrue;
    }

    return EFalse;
}


// ---------------------------------------------------------------------------
// IsDefaultSet check if default color is set
// ---------------------------------------------------------------------------
TBool CPaintCssValueImpl::IsDefaultSet()
	{
	return iDefaultSet;
	}


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CPaintCssValueImpl::SetElement(CSvgElementImpl* aElement)
{
	iSvgElementImpl = aElement;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgElementImpl* CPaintCssValueImpl::GetElement()
{
	return iSvgElementImpl;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CPaintCssValueImpl::Print()
{
#ifdef _DEBUG
	if (iValue)
	{
		RDebug::Printf("%d", (( TSvgColor* )iValue)->GetColor() );
	}
#endif
}