/*
* Copyright (c) 2007 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:   Image visual
*
*/



#include "alf/alfimagevisual.h"
#include "alf/alfcontrol.h"
#include "alf/alfenv.h"
#include "alfclient.h"
#include "alf/alfimage.h"
#include "alf/alfgencomponent.h"
#include "alf/alftexture.h" 
#include "alf/alfconstants.h"
#include "alflogger.h"
#include "alf/alfimageloaderutil.h"
#include "alfskinnableimage.h"
#include "alf/alfdropshadow.h"

#include <uiacceltk/HuiUtil.h>

// ======== LOCAL FUNCTIONS ========
#define FLOAT_COMPARE(a, b) (Abs(a-b)<0.0001f)

// Private data.
struct CAlfImageVisual::TImageVisualPrivateData
    {
    CAlfSkinnableImage* iImage;
    CAlfSkinnableImage* iSecondaryImage;    
    CAlfImageVisual::TScaleMode iScaleMode;
    };

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

// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
EXPORT_C CAlfImageVisual::CAlfImageVisual()
    {
    }


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::ConstructL(CAlfControl& aOwner)
    {
    CAlfVisual::ConstructL(aOwner);    
    iImageVisualData = new (ELeave) TImageVisualPrivateData;
    iImageVisualData->iImage = NULL;
    iImageVisualData->iSecondaryImage = NULL;
    
    iImageVisualData->iImage = new (ELeave) CAlfSkinnableImage(&aOwner.Env());
    iImageVisualData->iSecondaryImage = new (ELeave) CAlfSkinnableImage(&aOwner.Env());    
    iImageVisualData->iScaleMode = EScaleFit;
    }


// ---------------------------------------------------------------------------
// ?description_if_needed
// ---------------------------------------------------------------------------
//
EXPORT_C CAlfImageVisual::~CAlfImageVisual()
    {
    if (iImageVisualData)
        {
        delete iImageVisualData->iImage;
        iImageVisualData->iImage = NULL,
        
        delete iImageVisualData->iSecondaryImage;
        iImageVisualData->iSecondaryImage = NULL;        
        }
    
    delete iImageVisualData;
    iImageVisualData = NULL;
    }


// ---------------------------------------------------------------------------
// ?implementation_description
// ---------------------------------------------------------------------------
//
EXPORT_C CAlfImageVisual* CAlfImageVisual::AddNewL(
    CAlfControl& aOwnerControl,
    CAlfLayout* aParentLayout)
    {
    CAlfImageVisual* image = STATIC_CAST(CAlfImageVisual*,
        aOwnerControl.AppendVisualL(EAlfVisualTypeImage, aParentLayout));
    return image;
    }

// ---------------------------------------------------------------------------
// Sets scale mode.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetScaleMode(CAlfImageVisual::TScaleMode aScaleMode)
    {
    TPckgC<CAlfImageVisual::TScaleMode> buf(aScaleMode);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetScaleMode, buf);    
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetScaleMode ignore error %d", err )
        }
    else
        {
        iImageVisualData->iScaleMode = aScaleMode;
        }
    }
    
// ---------------------------------------------------------------------------
// Gets scale mode.
// ---------------------------------------------------------------------------
//
EXPORT_C CAlfImageVisual::TScaleMode CAlfImageVisual::ScaleMode()
    {
    CAlfImageVisual::TScaleMode ret = EScaleFit;
    if( iImageVisualData )
        {
        ret = iImageVisualData->iScaleMode;
        }            
    else
        {
        __ALFLOGSTRING( "CAlfImageVisual::ScaleMode Ignore ScaleMode iImageVisualData is NULL" )
        }
    return ret;
    }
// ---------------------------------------------------------------------------
// Sets image.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetImage(const TAlfImage& aImage)
    {    
    iImageVisualData->iImage->SetImage(aImage); // This texturizes skin graphics if needed

    TAlfImageParams params(iImageVisualData->iImage->Image());

    TPckgC<TAlfImageParams> buf(params);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetImage, buf);
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetImage ignore error %d", err )
        }
        
    }

// ---------------------------------------------------------------------------
// Sets secondary image.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetSecondaryImage(const TAlfImage& aImage)
    {        
    iImageVisualData->iSecondaryImage->SetImage(aImage); // This texturizes skin graphics if needed

    TAlfImageParams params(iImageVisualData->iSecondaryImage->Image());

    TPckgC<TAlfImageParams> buf(params);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetSecondaryImage, buf);
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetSecondaryImage ignore error %d", err )
        }
        
    }

// ---------------------------------------------------------------------------
// Sets secondary image alpha value.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetSecondaryAlpha(const TAlfTimedValue& aAlpha)
    {
    TPckgC<TAlfTimedValue> alphaPckg(aAlpha);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetSecondaryAlpha, alphaPckg );    
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetSecondaryAlpha ignore error %d", err )
        }
    }

// ---------------------------------------------------------------------------
// Gets image.
// ---------------------------------------------------------------------------
//
EXPORT_C const TAlfImage& CAlfImageVisual::Image() const
    {
    return iImageVisualData->iImage->Image();    
    }

// ---------------------------------------------------------------------------
// Gets secondary image.
// ---------------------------------------------------------------------------
//
EXPORT_C const TAlfImage& CAlfImageVisual::SecondaryImage() const
    {
    return iImageVisualData->iSecondaryImage->Image();            
    }

// ---------------------------------------------------------------------------
// Sets color.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetColor(const TRgb& aColor)
    {
    TPckgC<TRgb> buf(aColor);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetColor, buf );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetColor ignore error %d", err )
        }
    }

// ---------------------------------------------------------------------------
// Sets colormode.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetColorMode(CAlfImageVisual::TColorMode aColorMode, 
    TReal32 aParam) __SOFTFP
    {
    TIntTReal params(aColorMode, aParam);
    TPckg<TIntTReal> buf(params);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetColorMode, buf );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetColorMode ignore error %d", err )
        }
    }    
    
// ---------------------------------------------------------------------------
// Sets stretch.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetStretch(TInt aTop, TInt aBottom)
    {
    TInt2 params(aTop, aBottom);
    TPckg<TInt2> buf(params);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetStretch, buf );    
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetStretch ignore error %d", err )
        }
    }
    
// ---------------------------------------------------------------------------
// Sets stretchmode.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetStretchMode(CAlfGc::TStretchMode aStretchMode)
    {
    TPckg<CAlfGc::TStretchMode> buf(aStretchMode);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetStretchMode, buf );    
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetStretchMode ignore error %d", err )
        }
    }
    
// ---------------------------------------------------------------------------
// Sets drop shadow. (deprecated)
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetDropShadow(TInt aShadowDistance)
    {
    if ( aShadowDistance == 0 )
        {
        TRAP_IGNORE( EnableDropShadowL(EFalse) );
        return;
        }
        
    TRAPD( err, EnableDropShadowL() );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetDropShadow ignore error %d", err )
        return;
        }
        
    DropShadowHandler()->SetOffset( TAlfTimedPoint( aShadowDistance, aShadowDistance ) );
    }

// ---------------------------------------------------------------------------
// Sets drop shadow.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetDropShadow(const TAlfMetric& aShadowDistance)
    {
    SetDropShadow(TAlfXYMetric(aShadowDistance));
    }

// ---------------------------------------------------------------------------
// Sets drop shadow.
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetDropShadow(const TAlfXYMetric& aShadowDistance)
    {
    if ( FLOAT_COMPARE(aShadowDistance.iX.iMagnitude, 0.f ) && 
         FLOAT_COMPARE(aShadowDistance.iY.iMagnitude, 0.f ) )
        {
        TRAP_IGNORE( EnableDropShadowL(EFalse) );
        return;
        }
    
    TRAPD( err, EnableDropShadowL() );
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetDropShadow ignore error %d", err )
        return;
        }
        
    DropShadowHandler()->SetOffset( 
        TAlfTimedPoint( aShadowDistance.iX.iMagnitude,aShadowDistance.iY.iMagnitude ),
        aShadowDistance.iX.iUnit ); // assume that the unit for x and y are the same
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetTurnAngle(const TAlfTimedValue& aAngle)
    {
    TPckgC<TAlfTimedValue> pckg(aAngle);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetTurnAngle, pckg );            
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetTurnAngle ignore error %d", err )
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetScale(const TAlfTimedValue& aScale)
    {
    TPckgC<TAlfTimedValue> pckg(aScale);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetScale, pckg );                    
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetScale ignore error %d", err )
        }
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CAlfImageVisual::SetOffset(const TAlfTimedPoint& aOffset)
    {
    TPckgC<TAlfTimedPoint> pckg(aOffset);

    TInt err = Comms()->DoCmdNoReply(EAlfImageVisualSetOffset, pckg );                    
    
    if ( err )
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SetOffset ignore error %d", err )
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//    
EXPORT_C TAlfTimedValue CAlfImageVisual::SecondaryAlpha()
    {
    TAlfTimedValue value;
    TPckg<TAlfTimedValue> buf(value);
    TInt err = Comms()->DoSynchronousCmd( EAlfImageVisualSecondaryAlpha, 
        KNullDesC8, 
        buf);    
    
    if (err)
        {
        __ALFLOGSTRING1( "CAlfImageVisual::SecondaryAlpha panic error %d", err )
        USER_INVARIANT();
        }
    
    return value;            
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TAlfTimedValue CAlfImageVisual::TurnAngle()
    {
    TAlfTimedValue value;
    TPckg<TAlfTimedValue> buf(value);
    TInt err = Comms()->DoSynchronousCmd( EAlfImageVisualTurnAngle, 
        KNullDesC8, 
        buf);    
    
    if (err)
        {
        __ALFLOGSTRING1( "CAlfImageVisual::TurnAngle panic error %d", err )
        USER_INVARIANT();
        }
    
    return value;                    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TAlfTimedValue CAlfImageVisual::Scale()
    {
    TAlfTimedValue value;
    TPckg<TAlfTimedValue> buf(value);
    TInt err = Comms()->DoSynchronousCmd( EAlfImageVisualScale, 
        KNullDesC8, 
        buf);    
    
    if (err)
        {
        __ALFLOGSTRING1( "CAlfImageVisual::Scale panic error %d", err )
        USER_INVARIANT();
        }
    
    return value;                            
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TAlfTimedPoint CAlfImageVisual::Offset()
    {
    TAlfTimedPoint value;
    TPckg<TAlfTimedPoint> buf(value);
    TInt err = Comms()->DoSynchronousCmd( EAlfImageVisualOffset, 
        KNullDesC8, 
        buf);    
    
    if (err)
        {
        __ALFLOGSTRING1( "CAlfImageVisual::Offset panic error %d", err )
        USER_INVARIANT();
        }
    
    return value;                                    
    }
    
// ---------------------------------------------------------------------------
// Place holder from CAlfVisual
// ---------------------------------------------------------------------------
//     
EXPORT_C void CAlfImageVisual::RemoveAndDestroyAllD()
    {
    CAlfVisual::RemoveAndDestroyAllD();
    }
  
// ---------------------------------------------------------------------------
// Place holder from CAlfVisual
// ---------------------------------------------------------------------------
//  
EXPORT_C void CAlfImageVisual::UpdateChildrenLayout(TInt aTransitionTime )
    {
    CAlfVisual::UpdateChildrenLayout( aTransitionTime );
    }
  
// ---------------------------------------------------------------------------
// Place holder from CAlfVisual
// ---------------------------------------------------------------------------
//  
EXPORT_C CAlfVisual* CAlfImageVisual::FindTag(const TDesC8& aTag)
    {
    return CAlfVisual::FindTag( aTag );
    }

// ---------------------------------------------------------------------------
// Place holder from CAlfVisual
// ---------------------------------------------------------------------------
//  
EXPORT_C void CAlfImageVisual::DoRemoveAndDestroyAllD()
    {
    CAlfVisual::DoRemoveAndDestroyAllD();
    }
    
// ---------------------------------------------------------------------------
//  future proofing  
// ---------------------------------------------------------------------------
//  
EXPORT_C void CAlfImageVisual::PropertyOwnerExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
    {
    CAlfVisual::PropertyOwnerExtension(aExtensionUid,aExtensionParams);
    }