/*

* Copyright (c) 2002-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:  CCFContextUpdated class implementation.

*

*/

// INCLUDES

#include "cfcontextupdated.h"

#include "cfcontextoperationutils.h"

#include "cfbasicoptrace.h"

#include <gmxmlnode.h>

// CONSTANTS

_LIT( KScriptUpdatedName, "contextUpdated" );

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

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

// CCFContextUpdated::CCFContextUpdated

// C++ default constructor can NOT contain any code, that might leave.

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

//

CCFContextUpdated::CCFContextUpdated( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    HBufC* aName,

    HBufC* aSource )

    : CCFContextOperation( aServices, aParent, aName, aSource )

    {

    FUNC_LOG;

    }

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

// CCFContextUpdated::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCFContextUpdated::ConstructL( const TDesC& aValue )

    {

    FUNC_LOG;

    if ( aValue.Length() )

        {

        iCmpValue = aValue.AllocL();

        }

    }

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

// CCFContextUpdated::NewL

// Two-phased constructor.

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

//

CCFContextUpdated* CCFContextUpdated::NewL( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    const TDesC& aName,

    const TDesC& aSource,

    const TDesC& aValue )

    {

    FUNC_LOG;

    CCFContextUpdated* self

        = NewLC( aServices, aParent, aName, aSource, aValue );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCFContextUpdated::NewLC

// Two-phased constructor.

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

//

CCFContextUpdated* CCFContextUpdated::NewLC( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    const TDesC& aName,

    const TDesC& aSource,

    const TDesC& aValue )

    {

    FUNC_LOG;

    HBufC* name = aName.AllocLC();

    HBufC* source = aSource.AllocLC();

    CCFContextUpdated* self

        = new( ELeave ) CCFContextUpdated( aServices, aParent, name, source );

    CleanupStack::PushL( self );

    self->ConstructL( aValue );

    // Cleanup

    CleanupStack::Pop( self );

    CleanupStack::Pop( source );

    CleanupStack::Pop( name );

    CleanupStack::PushL( self );

    return self;

    }

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

// CCFContextUpdated::ParseL

// Construction with parsing from a DOM node.

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

//

CCFContextUpdated* CCFContextUpdated::ParseL( MCFOperationServices& aServices,

    CCFOperationNode* aParent,

    CMDXMLNode& aNode )

    {

    FUNC_LOG;

    if ( aNode.NodeName().CompareF( KScriptUpdatedName ) != 0 )

        {

        return NULL; // Cannot create context updated operation from the node.

        }

    TPtrC contextSource;

    TPtrC contextType;

    TPtrC contextValue;

    TInt contextLevelDelay( 0 );

    TBool argsOK( ETrue );

    TBool contextRefOK( EFalse );

    CMDXMLNode* child = aNode.FirstChild();

    while ( child )

        {

        if ( child->NodeType() == CMDXMLNode::EElementNode )

            {

            if ( !contextRefOK )

                {

                contextRefOK = CFContextOperationUtils::ParseContextRef(

                        *child,

                        contextSource,

                        contextType,

                        contextValue,

                        contextLevelDelay );

                if ( !contextRefOK )

                    {

                    argsOK = EFalse;

                    break;

                    }

                }

            else

                {

                argsOK = EFalse;

                break;

                }

            }

        else if ( child->NodeType() != CMDXMLNode::ECommentNode )

            {

            argsOK = EFalse; // Unsupported node encountered.

            break;

            }

        child = child->NextSibling();

        }

    CCFContextUpdated* self = NULL;

    if ( argsOK && contextRefOK )

        {

        self = NewL( aServices,

                aParent,

                contextType,

                contextSource,

                contextValue );

        if ( contextLevelDelay )

            {

            self->iContextLevelDelay = contextLevelDelay;

            }

        }

    else

        {

        INFO( "CCFContextUpdated::ParseL - Unsupported arguments" );

        }

    CREATE_DOM_INFO( self, aNode );

    return self;

    }

// Destructor

CCFContextUpdated::~CCFContextUpdated()

    {

    FUNC_LOG;

    delete iCmpValue;

    }

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

// CCFContextUpdated::IsAllRequired

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

//

TBool CCFContextUpdated::IsAllRequired() const

    {

    FUNC_LOG;

    return ETrue;

    }

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

// CCFContextUpdated::Evaluate

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

//

TBool CCFContextUpdated::Evaluate( const CCFContextObject& aContext,

    TInt& aContextLevelDelay )

    {

    FUNC_LOG;

    DOM_INFO( "CCFContextUpdated::Evaluate" );

    // Ask concrete implementation if it is true.

    TInt val( EFalse );

    TRAPD( err, val = IsTrueL( aContext ) );

    if ( err != KErrNone )

        {

        ERROR( err,

            "CCFContextUpdated: IsTrueL leave occurred, evaluation cancelled" );

        return EFalse;

        }

    // Evaluate parents if we have changed.

    if ( val != iValue )

        {

        INFO_1( "CCFContextUpdated::Evaluate - Value changed to (-1=undefined, 0=false, 1=true): %d", val );

        iValue = static_cast< TCFConditionValue >( val );

        if ( iParent )

            {

            iParent->Evaluate();

            }

        }

    else

        {

        INFO_1( "CCFContextUpdated::Evaluate - Value still (-1=undefined, 0=false, 1=true): %d", val );

        }

    if ( iPreviousTruthCheckWithReferencedContext )

        {

        aContextLevelDelay = iContextLevelDelay;

        }

    return ETrue;

    }

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

// CCFContextUpdated::IsTrueL

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

//

TBool CCFContextUpdated::IsTrueL( const CCFContextObject& aContext )

    {

    FUNC_LOG;

    TBool value( EFalse );

    if ( aContext.Source() == Source() && aContext.Type() == Type() )

        {

        // Context was updated, no need to check for change.

        if ( iCmpValue )

            {

            if ( aContext.Value() == *iCmpValue )

                {

                value = ETrue;

                }

            }

        else

            {

            value = ETrue;

            }

        iPreviousTruthCheckWithReferencedContext = ETrue;

        }

    else

        {

        iPreviousTruthCheckWithReferencedContext = EFalse;

        }

    return value;

    }