/*

* Copyright (c) 2008 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:   Drop shadow handler

*

*/

#include "uiacceltk/huidropshadow.h"

#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiTextureProcessor.h"

#include "uiacceltk/HuiTextureManager.h"

#include "uiacceltk/HuiEnv.h"

#include <AknsUtils.h>

#include <e32math.h>

// internal flags

enum

    {

    EHuiDropShadowChanged           = 0x01,

    EHuiDropShadowColorValid        = 0x02

    };

// ======== LOCAL FUNCTIONS ========

NONSHARABLE_STRUCT( CHuiDropShadow::THuiDropShadowData )

    {

    THuiDropShadowData():

        iColor(KRgbBlack), 

        iColorSkinId(), 

        iColorIndex(KErrNotFound), 

        //iColorValid(EFalse),

        //iChanged( EFalse )

        iFlags(0)

            {

            }

    mutable TRgb iColor;

    TAknsItemID iColorSkinId;

    TInt iColorIndex;

    //mutable TBool iColorValid;

    //TBool iChanged;

    TUint8 iFlags;

    };

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

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

// Default constructor

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

//

CHuiDropShadow::CHuiDropShadow() : 

    iOpacity(0.6f), 

    iOffset( 2.f, 2.f ),

    iOffsetUnit( EHuiUnitPixel ), // magnitude is in iTimedOffset

    iRadius( 1.5f ),

    iScale( 1.f  )

    {

    }

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

// 2nd phase constructor

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

//

void CHuiDropShadow::ConstructL()

    {

    iData = new (ELeave) THuiDropShadowData;

    }

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

// Destructor

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

//

CHuiDropShadow::~CHuiDropShadow()

    {

    if ( iData )

        {

        }

    delete iData;

    }

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

// Sets the shadow offset in polar coorsinates

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

//

EXPORT_C void CHuiDropShadow::SetOffset( 

    TReal32 aAngle, 

    THuiMetric aDistance, 

    TInt aTransitionTime ) __SOFTFP

    {

    if ( iOffsetUnit != aDistance.iUnit && aTransitionTime )

        {

        // @todo: convert current timed value into new unit

        }

    // it is not that efficient to use floating point calculations here

    // but this is not called often.

    TReal x;

    Math::Cos( x, 2.0*KPi*aAngle/360.0 );

    x*=aDistance.iMagnitude;

    TReal y;

    Math::Sin( y, 2.0*KPi*aAngle/360.0  );

    y*=-1.0*aDistance.iMagnitude;

    iOffset.Set( THuiRealPoint(x,y), aTransitionTime );

    iOffsetUnit = aDistance.iUnit;

    }

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

// Sets color in RGB

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

//        

EXPORT_C void CHuiDropShadow::SetColor(

    const TRgb& aColor, 

    TInt /*aTransitionTime*/)

    {

    iData->iColor = aColor;

    iData->iColorIndex = KErrNotFound;

    iData->iFlags |= EHuiDropShadowChanged;

    }

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

// Sets color in S60 skin

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

//

EXPORT_C void CHuiDropShadow::SetColor(

    const TAknsItemID& aID,

    const TInt aIndex, 

    TInt /*aTransitionTime*/)

    {

    iData->iColorSkinId = aID;

    iData->iColorIndex = aIndex;

    iData->iFlags &= ~EHuiDropShadowColorValid;

    iData->iFlags |= EHuiDropShadowChanged;

    }

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

// Returns the current color RGB value

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

// 

TRgb CHuiDropShadow::Color() const

    {

    if ( iData->iColorIndex != KErrNotFound && !(iData->iFlags&EHuiDropShadowColorValid) )

        {

        CHuiStatic::GetCachedColor(

                iData->iColor, 

                iData->iColorSkinId, 

                iData->iColorIndex);

        iData->iFlags |= EHuiDropShadowColorValid; // What about skins change..

        }

    return iData->iColor;

    }

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

// Returns ETrue if the drops shadow parateters have changed.

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

//

TBool CHuiDropShadow::Changed() const

    {

    if ( iData->iFlags&EHuiDropShadowChanged )

        {

        return ETrue;

        }

    return iOpacity.Changed() || iOffset.Changed() || iRadius.Changed() || iScale.Changed();

    }

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

// Clears all changed flags

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

//

void CHuiDropShadow::ClearChanged()

    {

    iData->iFlags &= ~EHuiDropShadowChanged;    

    iOpacity.ClearChanged();

    iOffset.ClearChanged();

    iRadius.ClearChanged();

    iScale.ClearChanged();

    }

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

// Calculates the drawging size of the shadow.

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

//    

THuiRealSize CHuiDropShadow::ShadowDrawingSize( 

    const TSize& aImageDrawingSize, 

    const TSize& aShadowTextureSize ) const

    {

    // Shadow texture is usually smaller than the image texture in which it is based on.

    // Also, the content of the shadow texture is shrank by the blur dimension

    // from all the sides.

    // round the blur dimension already because the blur filter does it as well.

    const TInt blurDimension = HUI_ROUND_FLOAT_TO_INT( 2*iRadius.Now() );

    // the content area of the texture is smaller than the the texture area

    THuiRealSize shadowContentSize = aShadowTextureSize;

    shadowContentSize.iWidth -= 2.f*blurDimension;

    shadowContentSize.iHeight -= 2.f*blurDimension;

    // check the relation between the shadow content area and the actial drawed image

    // check possible divide-by-xero case

    // The default value (1) is arbitrary. It only is there to allow prevention of divide_by_zero

    TReal32 xMultiplier = 1;

    if ( shadowContentSize.iWidth != 0 )

        {

        xMultiplier = ((TReal32)(aImageDrawingSize.iWidth)) / ((TReal32)(shadowContentSize.iWidth));

        }

    TReal32 yMultiplier = 1;

    if ( shadowContentSize.iHeight != 0 )

        {

        yMultiplier = ((TReal32)(aImageDrawingSize.iHeight)) / ((TReal32)(shadowContentSize.iHeight));

        }

    // apply the multiplier to the shadow texture

    THuiRealSize shadowDrawingSize = aShadowTextureSize;

    shadowDrawingSize.iWidth *= xMultiplier;

    shadowDrawingSize.iHeight *= yMultiplier;

    // apply the scale

    shadowDrawingSize.iWidth *= iScale.Now();

    shadowDrawingSize.iHeight *= iScale.Now();

    return shadowDrawingSize;

    }

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

// Returns ETrue if the shadow is visible

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

// 

TBool CHuiDropShadow::IsShadowVisible() const

    {

    return !HuiUtil::RealCompare( iScale.Now(), 0.f ) &&

           !HuiUtil::RealCompare( iOpacity.Now(), 0.f );

    }

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

// Gets the CHuiTexture from the MHuiTexture is applicable

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

//     

CHuiTexture* CHuiDropShadow::ShadowedTextureInstance( const MHuiTexture& aTextureIf )

    {

    CHuiTexture* resultTexture = NULL;

    const MHuiShadowedTexture* constShadowedTexture = aTextureIf.ShadowedTexture();

    if ( constShadowedTexture )

        {

        MHuiShadowedTexture* nonConstshadowedTexture = const_cast<MHuiShadowedTexture*>(constShadowedTexture);

        resultTexture = static_cast<CHuiTexture*>( nonConstshadowedTexture );

        }

    return resultTexture;

    }

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

// Returns shadow distance in pixels

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

//     

THuiRealPoint CHuiDropShadow::DistanceInPixels( const CHuiVisual& aReferenceVisual ) const

    {

    return aReferenceVisual.MetricToPixels( 

        THuiXYMetric( 

            THuiMetric( 

                iOffset.iX.Now(), 

                iOffsetUnit ), 

            THuiMetric( 

                iOffset.iY.Now(), 

                iOffsetUnit ) 

            ) 

        );

    }

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

// Returns shadow area

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

// 

THuiRealRect CHuiDropShadow::ShadowDrawingRealRect( 

        const TPoint& aImageDrawingPosition,

        const TSize& aImageDrawingSize, 

        const TSize& aShadowTextureSize,

        const CHuiVisual& aReferenceVisual  ) const

    {

    const THuiRealSize shadowDrawingSize = ShadowDrawingSize( aImageDrawingSize, aShadowTextureSize );

    THuiRealPoint shadowDrawingPos( aImageDrawingPosition );

    const THuiRealPoint distanceInPixels = DistanceInPixels( aReferenceVisual );

    shadowDrawingPos.iX += distanceInPixels.iX;

    shadowDrawingPos.iY += distanceInPixels.iY;

    shadowDrawingPos.iX -= (shadowDrawingSize.iWidth-aImageDrawingSize.iWidth )/2.f;

    shadowDrawingPos.iY -= (shadowDrawingSize.iHeight-aImageDrawingSize.iHeight )/2.f;

    return THuiRealRect( shadowDrawingPos, shadowDrawingSize );

    }

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

// Returns shadow area

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

//

TRect CHuiDropShadow::ShadowDrawingTRect( 

        const TPoint& aImageDrawingPosition,

        const TSize& aImageDrawingSize, 

        const TSize& aShadowTextureSize,

        const CHuiVisual& aReferenceVisual  ) const

    {

    const THuiRealRect realRect = ShadowDrawingRealRect( 

        aImageDrawingPosition, 

        aImageDrawingSize, 

        aShadowTextureSize, 

        aReferenceVisual );

    return TRect( HUI_ROUND_FLOAT_TO_INT( realRect.iTl.iX ),

                  HUI_ROUND_FLOAT_TO_INT( realRect.iTl.iY ),

                  HUI_ROUND_FLOAT_TO_INT( realRect.iBr.iX ),

                  HUI_ROUND_FLOAT_TO_INT( realRect.iBr.iY ) );

    }