/*

* Copyright (c) 2005-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:  Utility class for effects.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include "AknsRlEffectUtil.h"

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

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

// AknsRlUtil::Median9

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

//

#define AKNS_RL_EFFECT_SORT(a, b) { if((a) > (b)) { temp=(a); (a) = (b); (b) = temp; } }

TUint8 AknsRlUtil::Median9( TUint8 aArray[9] )

    {

    TUint8 temp; // Defined for AKNS_RL_EFFECT_SORT macro

    AKNS_RL_EFFECT_SORT(aArray[1], aArray[2]); AKNS_RL_EFFECT_SORT(aArray[4], aArray[5]); AKNS_RL_EFFECT_SORT(aArray[7], aArray[8]);

    AKNS_RL_EFFECT_SORT(aArray[0], aArray[1]); AKNS_RL_EFFECT_SORT(aArray[3], aArray[4]); AKNS_RL_EFFECT_SORT(aArray[6], aArray[7]);

    AKNS_RL_EFFECT_SORT(aArray[1], aArray[2]); AKNS_RL_EFFECT_SORT(aArray[4], aArray[5]); AKNS_RL_EFFECT_SORT(aArray[7], aArray[8]);

    AKNS_RL_EFFECT_SORT(aArray[0], aArray[3]); AKNS_RL_EFFECT_SORT(aArray[5], aArray[8]); AKNS_RL_EFFECT_SORT(aArray[4], aArray[7]);

    AKNS_RL_EFFECT_SORT(aArray[3], aArray[6]); AKNS_RL_EFFECT_SORT(aArray[1], aArray[4]); AKNS_RL_EFFECT_SORT(aArray[2], aArray[5]);

    AKNS_RL_EFFECT_SORT(aArray[4], aArray[7]); AKNS_RL_EFFECT_SORT(aArray[4], aArray[2]); AKNS_RL_EFFECT_SORT(aArray[6], aArray[4]);

    AKNS_RL_EFFECT_SORT(aArray[4], aArray[2]);

    return(aArray[4]);

    }

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

// AknsRlChannelBlend::Blend

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

//

TUint8 AknsRlChannelBlend::Blend( const TAknsRlChannelBlendMode aMode,

                                  const TInt aFactor,

                                  const TUint8 aA,

                                  const TUint8 aB )

    {

    // Some calculations will result in negative values, res must be signed

    TInt res = 0;

    // Note: It is assumed that arithmetic shifting is supported

    // -> negative values are shifted correctly

    switch(aMode)

        {

        case EAknsRlChannelBlendNormal:

            {

            res = aB;

            }

            break;

        case EAknsRlChannelBlendDarken:

            {

            if( aA < aB )

                res = aA;

            else

                res = aB;

            }

            break;

        case EAknsRlChannelBlendLighten:

            {

            if( aA > aB )

                res = aA;

            else

                res = aB;

            }

            break;

        case EAknsRlChannelBlendMultiply:

            {

            res = ( aA * aB ) >> 8;

            }

            break;

        case EAknsRlChannelBlendScreen:

            {

            res = 255 - ((( 255 - aA ) * ( 255 - aB )) >> 8 ); //lint !e702 Arithmetic shifting assumed

            }

            break;

        case EAknsRlChannelBlendOverlay:

            {

            if( aA < 127 )

                res = 2 * (( aA * aB ) >> 8);

            else

                res = 255 - 2 * ((( 255 - aA ) * ( 255 - aB )) >> 8 ); //lint !e702 Arithmetic shifting assumed

            }

            break;

        case EAknsRlChannelBlendHardLight:

            {

            if( aB < 127 )

                res = 2 * (( aA * aB ) >> 8 );

            else

                res = 255 - 2 * ((( 255 - aA ) * ( 255 - aB )) >> 8 ); //lint !e702 Arithmetic shifting assumed

            }

            break;

        case EAknsRlChannelBlendSoftLight:

            {

            res = 2 * (( aA * aB ) >> 8 ) + (( aA * aA ) >> 8 ) - 2 * (( aA * (( aA * aB ) >> 8 )) >> 8 ); //lint !e702 Arithmetic shifting assumed

            }

            break;

        case EAknsRlChannelBlendDifference:

            {

            res = aA - aB;

            if( res < 0 )

                res = -res;

            }

            break;

        case EAknsRlChannelBlendDodge:

            {

            if( 255 == aB )

                res = 255;

            else

                {

                res = ( aA << 8 ) / ( 255 - aB );

                // Do clamping here to prevent artefacts in blending

                if( res < 0 )

                    res = 0;

                if( res > 255 )

                    res = 255;

                }

            }

            break;

        case EAknsRlChannelBlendBurn:

            {

            if( 0 == aB )

                res = 0; // This makes burn work as in Paint Shop Pro

            else

                {

                res = 255 - ((( 255 - aA ) << 8 ) / aB );

                // Do clamping here to prevent artefacts in blending

                if( res < 0 )

                    res = 0;

                if( res > 255 )

                    res = 255;

                }

            }

            break;

        default:

            break;

        }

    // Blend between result and the original value

    res = ( res * aFactor + ( 255 - aFactor ) * aA ) >> 8; //lint !e702 Arithmetic shifting assumed

    // Clamp the result to range [0, 255]

    if( res < 0 )

        return 0;

    if( res > 255 )

        return 255;

    return TUint8(res);

    }

// End of file.