/*
* Copyright (c) 2008-2009 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:    View-transition animations
*
*/




/**
 * @internal reviewed 12/07/2007 by Michael Yip
 */

#include "glxanimationview.h"

#include <alf/alfcontrol.h>
#include <alf/alfcontrolgroup.h>
#include <alf/alftransformation.h>


const TReal KGlxViewSwitchBackgroundScalingFactor = 0.2;
const TReal KGlxViewSwitchForegroundScalingFactor = 0.3;



// -----------------------------------------------------------------------------
// NewL
// -----------------------------------------------------------------------------
//
CGlxAnimationView* CGlxAnimationView::NewL( 
        TGlxViewswitchAnimation aAnimType, 
        TGlxNavigationDirection aDirection, 
        const RPointerArray<CAlfControlGroup>& aControlGroups)
    {
    CGlxAnimationView* self = new (ELeave) CGlxAnimationView(aAnimType, aDirection);
    CleanupStack::PushL(self);
    self->ConstructL(aControlGroups);
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
//
CGlxAnimationView::CGlxAnimationView(
        TGlxViewswitchAnimation aAnimType, 
        TGlxNavigationDirection aDirection)
:   iAnimType(aAnimType),
    iDirection(aDirection)
    {
    }

// -----------------------------------------------------------------------------
// ConstructL
// -----------------------------------------------------------------------------
//
void CGlxAnimationView::ConstructL(const RPointerArray<CAlfControlGroup>& aControlGroups)
    {
    TInt count = aControlGroups.Count();
    
    for (TInt index = 0; index < count; index++)
        {
        iControlGroups.AppendL(aControlGroups[index]);
        }
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CGlxAnimationView::~CGlxAnimationView()
    {
    iControlGroups.Close();
    }
    
// -----------------------------------------------------------------------------
// StartTimedAnimationL
// -----------------------------------------------------------------------------
//
void CGlxAnimationView::StartTimedAnimationL( TInt aTime )
    {
    // Set up timed values
    TAlfTimedValue scale( 1.0 );
    TAlfTimedValue opacity( 1.0 );

    // Set the scaling effect    
    if ( EGlxNavigationForwards == iDirection )
        {
        if( EGlxViewAnimationEntry == iAnimType )
            {
            scale.SetValueNow( 1 - KGlxViewSwitchBackgroundScalingFactor );
            scale.SetTarget( 1, aTime ); // and target
            }
        else if ( EGlxViewAnimationExit == iAnimType )
            {
            scale.SetValueNow( 1 );
            scale.SetTarget( 1 + KGlxViewSwitchForegroundScalingFactor, aTime ); // and target
            }
        }
    else if ( EGlxNavigationBackwards == iDirection )
        {
        if( EGlxViewAnimationEntry == iAnimType )
            {
            scale.SetValueNow( 1 + KGlxViewSwitchForegroundScalingFactor );
            scale.SetTarget( 1, aTime ); // and target
            }
        else if ( EGlxViewAnimationExit == iAnimType )
            {
            scale.SetValueNow( 1 );
            scale.SetTarget( 1 - KGlxViewSwitchBackgroundScalingFactor, aTime ); // and target
            }
        }

    // Set the opacity effect
    if( EGlxViewAnimationEntry == iAnimType )
        {
        opacity.SetValueNow( 0 );
        opacity.SetTarget(1.0, aTime );
        }
    else if ( EGlxViewAnimationExit == iAnimType )
        {
        opacity.SetValueNow( 1.0 );
        opacity.SetTarget(0.0, aTime );
        }
    opacity.SetStyle(EAlfTimedValueStyleLinear);

    // Find out the screen size
    CGlxUiUtility* uiUtility = CGlxUiUtility::UtilityL();
    CleanupClosePushL( *uiUtility );
    CleanupStack::PopAndDestroy( uiUtility );

    // Animate each of the control groups
    TInt cgCount = iControlGroups.Count();
    for ( TInt cg = 0; cg < cgCount; cg++ )
        {
        // If exiting, disable input events
        if ( EGlxViewAnimationExit == iAnimType )
            {
            iControlGroups[cg]->SetAcceptInput( EFalse );
            }

        // Set up control group transformations
        iControlGroups[cg]->EnableTransformationL();
        CAlfTransformation& trans = iControlGroups[cg]->Transformation();
        trans.Scale( scale, scale );
        
        // Set opacity of all toplevel visuals in all controls in this group
        TInt controlCount = iControlGroups[cg]->Count();
        for(TInt i = 0; i < controlCount; i++ )
            {
            CAlfControl& control = iControlGroups[cg]->Control(i);
            for(TInt j = 0; j < control.VisualCount(); j++)
                {
                if ( control.Visual(j).Layout() )
                    {
                    control.Visual(j).SetOpacity( opacity );
                    }
                }
            }
        }
    }