/*

* Copyright (c) 2004 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:   Implementation of the audio EnvironmentalReverb proxy class

*

*/

// INCLUDE FILES

#ifdef _DEBUG

#include <e32svr.h>

#endif

#include "TempEnvironmentalReverb.h"

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

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

// CTempEnvironmentalReverb::CTempEnvironmentalReverb

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

// might leave.

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

//

CTempEnvironmentalReverb::CTempEnvironmentalReverb()

    {

    }

// Destructor

CTempEnvironmentalReverb::~CTempEnvironmentalReverb()

    {

	}

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

// CTempEnvironmentalReverb::NewL

// Static function for creating an instance of the Audio EnvironmentalReverb object.

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

//

EXPORT_C CTempEnvironmentalReverb* CTempEnvironmentalReverb::NewL(CEnvironmentalReverb* aEnvironmentalReverb)

    {

#ifdef _DEBUG

		    RDebug::Print(_L("CTempEnvironmentalReverb::NewL"));

#endif

    CTempEnvironmentalReverb* self = new (ELeave) CTempEnvironmentalReverb();

    CleanupStack::PushL( self );

	self->ConstructL(aEnvironmentalReverb);

	CleanupStack::Pop(self);

    return self;

	}

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

// CTempEnvironmentalReverb::ConstructL

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

//

void CTempEnvironmentalReverb::ConstructL(CEnvironmentalReverb* aEnvironmentalReverb)

    {

#ifdef _DEBUG

    RDebug::Print(_L("CTempEnvironmentalReverb::ConstructL"));

#endif

	iEnvironmentalReverb = aEnvironmentalReverb;

	}

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

// CTempEnvironmentalReverb::ApplyL

// Apply the Audio EnvironmentalReverb settings.

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

//

EXPORT_C void CTempEnvironmentalReverb::ApplyL()

	{

#ifdef _DEBUG

    RDebug::Print(_L("CTempEnvironmentalReverb::Apply"));

#endif

    if (DecayHFRatio() != iEnvironmentalReverb->DecayHFRatio())

      iEnvironmentalReverb->SetDecayHFRatioL (DecayHFRatio());

    if (DecayTime() != iEnvironmentalReverb->DecayTime())

      iEnvironmentalReverb->SetDecayTimeL (DecayTime());

    if (Density() != iEnvironmentalReverb->Density())

      iEnvironmentalReverb->SetDensityL ( Density());

    if (Diffusion() != iEnvironmentalReverb->Diffusion())

      iEnvironmentalReverb->SetDiffusionL (Diffusion());

    if (ReflectionsLevel() != iEnvironmentalReverb->ReflectionsLevel())

      iEnvironmentalReverb->SetReflectionsLevelL (ReflectionsLevel());

    if (ReflectionsDelay() != iEnvironmentalReverb->ReflectionsDelay())

      iEnvironmentalReverb->SetReflectionsDelayL (ReflectionsDelay());

    if (ReverbDelay() != iEnvironmentalReverb->ReverbDelay())

      iEnvironmentalReverb->SetReverbDelayL (ReverbDelay());

    if (ReverbLevel() != iEnvironmentalReverb->ReverbLevel())

      iEnvironmentalReverb->SetReverbLevelL (ReverbLevel());

    if (RoomHFLevel() != iEnvironmentalReverb->RoomHFLevel())

      iEnvironmentalReverb->SetRoomHFLevelL (RoomHFLevel());

    if (RoomLevel() != iEnvironmentalReverb->RoomLevel())

      iEnvironmentalReverb->SetRoomLevelL (RoomLevel());

    if(iEnvironmentalReverb)

	  iEnvironmentalReverb->EnableL();

	}

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

// CTempEnvironmentalReverb::EnableL

// Enable the Audio EnvironmentalReverb settings.

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

//

EXPORT_C void CTempEnvironmentalReverb::EnableL()

   {

   #ifdef _DEBUG

   	RDebug::Print(_L("CTempEnvironmentalReverb::EnableL"));

   	#endif

   	iEnabled = ETrue;

    ApplyL();  

   }

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

// CTempEnvironmentalReverb::DisableL

// Disable the Audio EnvironmentalReverb settings.

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

//

EXPORT_C void CTempEnvironmentalReverb::DisableL()

   {

   #ifdef _DEBUG   

   	 RDebug::Print(_L("CTempEnvironmentalReverb::DisableL"));

   #endif

   	iEnabled = EFalse;   	 

	if(iEnvironmentalReverb)

	  iEnvironmentalReverb->DisableL();	    

   }

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

// CTempEnvironmentalReverb::IsEnableL

// Return enable flag.

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

//

EXPORT_C TBool CTempEnvironmentalReverb::IsEnabled() const

   {

   #ifdef _DEBUG 

   	 RDebug::Print(_L("CTempEnvironmentalReverb::IsEnabled"));

   #endif

    TBool ifEnabled = EFalse;

    if(iEnvironmentalReverb)

	   ifEnabled = iEnvironmentalReverb->IsEnabled();	    

    return ifEnabled;

   }

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

// CTempEnvironmentalReverb::IsEnforced

// Return enForce flag

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

//

EXPORT_C TBool CTempEnvironmentalReverb::IsEnforced() const

   {

   #ifdef _DEBUG 

   RDebug::Print(_L("CTempEnvironmentalReverb::IsEnforced"));

   #endif

    TBool ifEnforced = EFalse;   

    if(iEnvironmentalReverb)

	  ifEnforced = iEnvironmentalReverb->IsEnforced();	    	

    return ifEnforced;

   }

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

// CTempEnvironmentalReverb::EnforceL

// Enforce the effect

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

//

EXPORT_C void CTempEnvironmentalReverb::EnforceL( TBool aEnforced )

   {

   #ifdef _DEBUG 

   RDebug::Print(_L("CTempEnvironmentalReverb::EnforceL"));

   #endif    

   iEnforced = aEnforced;

   if(iEnvironmentalReverb)

	  iEnvironmentalReverb->EnforceL(aEnforced);	   	

   }

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

// CTempEnvironmentalReverb::HaveUpdateRights

// Return enForce flag

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

//

EXPORT_C TBool CTempEnvironmentalReverb::HaveUpdateRights() const

   {

   #ifdef _DEBUG 

   RDebug::Print(_L("CTempEnvironmentalReverb::HaveUpdateRights"));

   #endif

    TBool ifHaveUpdateRights = EFalse;   

    if(iEnvironmentalReverb)

	  ifHaveUpdateRights = iEnvironmentalReverb->HaveUpdateRights();	    	

    return ifHaveUpdateRights;

   }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// End of File