// 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:

//

#include <imageprocessor/imageprocessoreffect.h>

#include <imageprocessor/imageprocessorplugineffect.h>

#include "imageprocessorimpl.h"

#include <imageprocessor/imageprocessor.h>

namespace ImageProcessor

   {

/**

Constructor.

@param aUid The uid of the effect.

@param aPluginEffect The effect plugin.

@param aImageProcessorImpl The image processor implementation.

*/	

TEffect::TEffect(const TUid& aUid, Plugin::MEffect& aPluginEffect, CImageProcessorImpl& aImageProcessorImpl): 

	iPluginEffect(aPluginEffect), 

	iUid(aUid),

	iIsActive(EFalse),

	iImageProcessorImpl(aImageProcessorImpl),

	iReserved(0)

	{

	}

/**

The begin function of effects, which is first part of the three stages/functions: "begin -> set -> end". .

*/

EXPORT_C void TEffect::BeginL()

	{

	__ASSERT_ALWAYS(iImageProcessorImpl.IsInputSet(),  User::Leave(KErrNotReady)); 

	__ASSERT_ALWAYS(!iIsActive, User::Leave(KErrNotReady));

	iImageProcessorImpl.SetStateL(CImgProcessor::EEffectActive);

	TRAPD(err, iPluginEffect.BeginL());

	if (err != KErrNone) 

		{

		iImageProcessorImpl.RestoreStateL();

		User::Leave(err);

		}

	iIsActive = ETrue;

	}

/**

The end function of effects, which is last part of the three stages/functions: "begin -> set -> end". .

*/

EXPORT_C void TEffect::EndL()

	{

	__ASSERT_ALWAYS(iIsActive, User::Leave(KErrNotReady));

	iImageProcessorImpl.CheckStateL(CImgProcessor::EEffectActive);

	TRAPD(err, iPluginEffect.EndL());

 	if (err != KErrNone)

 		{

 		iImageProcessorImpl.SetStateL(CImgProcessor::EInitialized);

 		iIsActive = EFalse;

 		User::Leave(err);			

 		}

	iIsActive = EFalse;

	iImageProcessorImpl.SetStateL(CImgProcessor::EInitialized);

	}

/**

Retrieves the input type for the effect.

@return	TEffectInputType corresponding to the level type. 

*/

EXPORT_C TEffect::TEffectInputType TEffect::InputType() const

	{

		{

		TInt minimumLevel = 0;

		TInt maximumLevel = 0;

		TInt levelStep = 0;

		LevelSettings(minimumLevel, maximumLevel, levelStep);

		if (minimumLevel != maximumLevel) 

			{

			return EEffectInputTypeInt;

			}

		}

		{

		TReal32 minimumLevel = 0.0f;

		TReal32 maximumLevel = 0.0f;

		TReal32 levelStep = 0.0f;

		LevelSettings(minimumLevel, maximumLevel, levelStep);

		if (minimumLevel != maximumLevel)// 0.0f == 0.0f - it is always true

			{

			return EEffectInputTypeReal32;

			}

		}

	return EEffectInputTypeCustom;

	}

/**

Sets the level to the effect.

@param	aLevel

		The level value to be set.

@leave  KErrNotReady

		The effect is not active. The effect should be set active by calling TEffect::BeginL() function. 

		@see TEffect::BeginL()

@leave  KErrArgument

		The level is not in the level range. The range can be queried by calling TEffect::LevelSettings(TInt& aMinimumLevel, TInt& aMaximumLevel, TInt& aLevelStep) function.

		@see TEffect::LevelSettings(TInt& aMinimumLevel, TInt& aMaximumLevel, TInt& aLevelStep)

@leave  KErrNotSupported

		The input type is not supported by the effect. The supported input type can be queried by calling TEffect::InputType function.

		@see TEffect::InputType()

*/

EXPORT_C void TEffect::SetLevelL(TInt aLevel)

	{

	__ASSERT_ALWAYS(iIsActive, User::Leave(KErrNotReady));

	TInt minimumLevel = 0;

	TInt maximumLevel = 0;

	TInt levelStep = 0;

	LevelSettings(minimumLevel, maximumLevel, levelStep);

	if (minimumLevel != maximumLevel) 

		{

		__ASSERT_ALWAYS((minimumLevel <= aLevel) && (maximumLevel >= aLevel), User::Leave(KErrArgument));

		iPluginEffect.SetLevelL(aLevel);

		}

	else 

		{

		User::Leave(KErrNotSupported);

		}

	}

/**

Retrieves the effect level.

@param	aLevel

		The level value.

@leave  KErrNotSupported

		The input type is not supported by the effect. The supported input type can be queried by calling TEffect::InputType function.

		@see TEffect::InputType()

*/

EXPORT_C void TEffect::LevelL(TInt& aLevel) const

	{

	iPluginEffect.LevelL(aLevel);

	}

/**

Retrieves the effect level range. If minimum level equals the maximum level the particular input type is not supported.

@param	aMinimumLevel

		The minimum value of the level.

@param	aMaximumLevel 

		The maximum value of the level.

@param	aLevelStep

		The value of the level step. The level step defines the level range resolution between minimim and maximum

		levels.

*/

EXPORT_C void TEffect::LevelSettings(TInt& aMinimumLevel, TInt& aMaximumLevel, TInt& aLevelStep) const

	{

	iPluginEffect.LevelSettings(aMinimumLevel, aMaximumLevel, aLevelStep);

	}

/**

Sets the level to the effect.

@param	aLevel

		The level value to be set.

@leave  KErrNotReady

                The effect is not active. The effect should be set active by calling TEffect::BeginL() function. 

		@see TEffect::BeginL()

@leave  KErrArgument

                The level is not in the level range. The range can be queried by calling TEffect::LevelSettings(TReal32& aMinimumLevel, TReal32& aMaximumLevel, TReal32& aLevelStep) function.

		@see TEffect::LevelSettings(TReal32& aMinimumLevel, TReal32& aMaximumLevel, TReal32& aLevelStep)

@leave  KErrNotSupported

                The input type is not supported for the effect. The supported input type can be queried by calling TEffect::InputType function.

		@see TEffect::InputType()

*/

EXPORT_C void TEffect::SetLevelL(TReal32 aLevel)

	{

	__ASSERT_ALWAYS(iIsActive, User::Leave(KErrNotReady));

	TReal32 minimumLevel = 0.0f;

	TReal32 maximumLevel = 0.0f;

	TReal32 levelStep = 0.0f;

	LevelSettings(minimumLevel, maximumLevel, levelStep);

	if (minimumLevel != maximumLevel) 

		{

		__ASSERT_ALWAYS((minimumLevel <= aLevel) && (maximumLevel >= aLevel), User::Leave(KErrArgument));

		iPluginEffect.SetLevelL(aLevel);

		}

	else 

		{

		User::Leave(KErrNotSupported);

		}

	iPluginEffect.SetLevelL(aLevel);

	}

/**

Retrieves the effect level.

@param	aLevel

		The level value.

@leave  KErrNotSupported

		The input type is not supported by the effect. The supported input type can be queried by calling TEffect::InputType function.

		@see TEffect::InputType()

*/

EXPORT_C void TEffect::LevelL(TReal32& aLevel) const

	{

	iPluginEffect.LevelL(aLevel);

	}

/**

Retrieves the effect level range. If minimum level equals the maximum level the particular input type is not supported.

@param	aMinimumLevel

		The minimum value of the level.

@param	aMaximumLevel 

		The maximum value of the level.

@param	aLevelStep

		The value of the level step. The level step defines the level range resolution between minimim and maximum

		levels.

*/

EXPORT_C void TEffect::LevelSettings(TReal32& aMinimumLevel, TReal32& aMaximumLevel, TReal32& aLevelStep) const

	{

	iPluginEffect.LevelSettings(aMinimumLevel, aMaximumLevel, aLevelStep);

	}

/**

The reset function of effects, which resets the effect parameters and state.

*/

EXPORT_C void TEffect::ResetL()

	{

	TInt err = KErrNone;

	if (iIsActive) 

		{

		EndL();

		//try to undo the effect as it was reset.

		TRAP(err, iImageProcessorImpl.UndoL());

		}

	iPluginEffect.ResetL();

	}

/**

Retrieves access to a custom extension.

@param	aExtension

		The UID of the extension to be retrieved

@return	Extension corresponding to the UID given as a parameter.

*/

EXPORT_C TAny* TEffect::Extension(TUid /*aExtension*/)

	{

	return NULL;	

	}

TEffectSepia::TEffectSepia(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectSepiaUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectGrayscale::TEffectGrayscale(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectGrayscaleUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectNegative::TEffectNegative(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectNegativeUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectGrayscaleNegative::TEffectGrayscaleNegative(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectGrayscaleNegativeUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectOily::TEffectOily(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectOilyUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectPaint::TEffectPaint(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectPaintUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectMilky::TEffectMilky(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectMilkyUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectFog::TEffectFog(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectFogUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectAntique::TEffectAntique(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectAntiqueUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectMirrorLeftToRight::TEffectMirrorLeftToRight(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectMirrorLeftToRightUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectMagicPen::TEffectMagicPen(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectMagicPenUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectBrightness::TEffectBrightness(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectBrightnessUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectSharpness::TEffectSharpness(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectSharpnessUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectRotation::TEffectRotation(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectRotationUid, aEffect, aImageProcessorImpl)

	{

	}

/**

Gets the current rotation scale mode

@return	The rotation scale mode

*/

EXPORT_C TEffectRotation::TRotationScaleMode TEffectRotation::ScaleModeL() const

	{

	return (reinterpret_cast<Plugin::MEffectRotation&>(iPluginEffect)).ScaleModeL();

	}

/**

Gets the current rotation angle

@return	The rotation angle

*/

EXPORT_C TReal32 TEffectRotation::AngleL() const

	{

	return (reinterpret_cast<Plugin::MEffectRotation&>(iPluginEffect)).AngleL();

	}

/**

Specifies the rotation scale mode and angle for the current rotation effect

@param	aScaleMode

        The rotation scale mode. Range (1) - (3).  

@param	aAngle

        The rotation amgle. Range (0.0f) - (360.0f).  

@leave	KErrNotReady

		The effect is not active.

@leave	KErrArgument

		The level is not in the TRotationScaleMode enumeration or angle is not in the acceptable range.

*/

EXPORT_C void TEffectRotation::SetRotationL(TEffectRotation::TRotationScaleMode aScaleMode, TReal32 aAngle)

	{

	__ASSERT_ALWAYS(iIsActive, User::Leave(KErrNotReady));

	(reinterpret_cast<Plugin::MEffectRotation&>(iPluginEffect)).SetRotationL(aScaleMode, aAngle);

	}

TEffectContrast::TEffectContrast(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectContrastUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectRgbColorAdjust::TEffectRgbColorAdjust(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectRgbColorAdjustUid, aEffect, aImageProcessorImpl)

	{

	}

/**

Gets the current red level of RgbColorAdjust effect 

@return	The red level

*/

EXPORT_C TReal32 TEffectRgbColorAdjust::RedLevelL() const

	{

	return (reinterpret_cast<Plugin::MEffectRgbColorAdjust&>(iPluginEffect)).RedLevelL();

	}

/**

Gets the current green level of RgbColorAdjust effect 

@return	The green level

*/

EXPORT_C TReal32 TEffectRgbColorAdjust::GreenLevelL() const

	{

	return (reinterpret_cast<Plugin::MEffectRgbColorAdjust&>(iPluginEffect)).GreenLevelL();

	}

/**

Gets the current blue level of RgbColorAdjust effect 

@return	The blue level

*/

EXPORT_C TReal32 TEffectRgbColorAdjust::BlueLevelL() const

	{

	return (reinterpret_cast<Plugin::MEffectRgbColorAdjust&>(iPluginEffect)).BlueLevelL();

	}

/**

Specifies the red, green and blue level for the current RgbColorAdjust effect

@param	aRedLevel

        The red channel adjustment. Range (-1.0) - (1.0), where 0.0 implies no adjustment.

@param	aGreenLevel

        The green channel adjustment. Range (-1.0) - (1.0), where 0.0 implies no adjustment.

@param	aBlueLevel

        The blue channel adjustment. Range (-1.0) - (1.0), where 0.0 implies no adjustment.

@leave	KErrNotReady

		The effect is not active.

@leave	KErrArgument

		The red level, or green level, or blue level is not in the acceptable range.

*/   

EXPORT_C void TEffectRgbColorAdjust::SetRGBLevelL(TReal32 aRedLevel, TReal32 aGreenLevel, TReal32 aBlueLevel)

	{

	__ASSERT_ALWAYS(iIsActive, User::Leave(KErrNotReady));

	(reinterpret_cast<Plugin::MEffectRgbColorAdjust&>(iPluginEffect)).SetRGBLevelL(aRedLevel, aGreenLevel, aBlueLevel);

	}

TEffectEmboss::TEffectEmboss(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectEmbossUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectSolarize::TEffectSolarize(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectSolarizeUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectPosterize::TEffectPosterize(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectPosterizeUid, aEffect, aImageProcessorImpl)

	{

	}

TEffectStamp::TEffectStamp(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectStampUid, aEffect, aImageProcessorImpl)

	{

	}

/**

Gets the smoothness level for the current stamp effect

@return	The smoothness level

*/

EXPORT_C TInt TEffectStamp::SmoothnessLevelL() const

	{

	return (reinterpret_cast<Plugin::MEffectStamp&>(iPluginEffect)).SmoothnessLevelL();

	}

/**

Gets the threshold level for the current stamp effect

@return	The threshold level

*/

EXPORT_C TInt TEffectStamp::ThresholdLevelL() const

	{

	return (reinterpret_cast<Plugin::MEffectStamp&>(iPluginEffect)).ThresholdLevelL();

	}

/**

Specifies the smoothness and threshold level for the current stamp effect

@param	aSmoothnessLevel

        The smoothness level. Range (0) - (6), where 0.0 implies no adjustment.

@param	aThresholdLevel

        The threshold level. Range (0) - (255), where 0.0 implies no adjustment.

@leave	KErrNotReady

		The effect is not active.

@leave	KErrArgument

		The smoothness or threshold level is not in the acceptable range.

*/

EXPORT_C void TEffectStamp::SetStampLevelL(TInt aSmoothnessLevel, TInt aThresholdLevel)

	{

	__ASSERT_ALWAYS(iIsActive, User::Leave(KErrNotReady));

	(reinterpret_cast<Plugin::MEffectStamp&>(iPluginEffect)).SetStampLevelL(aSmoothnessLevel, aThresholdLevel);

	}

TEffectSketch::TEffectSketch(Plugin::MEffect& aEffect, CImageProcessorImpl& aImageProcessorImpl) : 

	TEffect(KEffectSketchUid, aEffect, aImageProcessorImpl)

	{

	}

/**

Get the current sketch mode

@return	The sketch mode

*/ 

EXPORT_C TEffectSketch::TSketchMode TEffectSketch::SketchModeL() const

	{

	return (TEffectSketch::TSketchMode)(reinterpret_cast<Plugin::MEffectSketch&>(iPluginEffect)).SketchModeL();