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


// INCLUDE FILES
#include <bitdev.h>
#include <eikenv.h>
#include <eikspane.h>
#include <AknUtils.h>
#include <AknsDrawUtils.h>

#include "AknIndicatorFader.h"
#include "AknIndicatorContainer.h"
#include "AknIndicator.h"


// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

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

// -----------------------------------------------------------------------------
// CAknIndicatorFader::CAknIndicatorFader
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CAknIndicatorFader::CAknIndicatorFader(TSize aSize)
    {
    iSize = aSize;
    }

// -----------------------------------------------------------------------------
// CAknIndicatorFader::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CAknIndicatorFader::ConstructL()
    {
    iFadedBitmap = new (ELeave) CFbsBitmap();
    iFadedBitmap->Create(iSize, EGray256);    

    iFadingBitmap = new (ELeave) CFbsBitmap();
    iFadingBitmap->Create(iSize, EGray256);
    
    iInvertingBitmap = new (ELeave) CFbsBitmap();
    iInvertingBitmap->Create(iSize, EGray2);

    iInvertedBitmap = new (ELeave) CFbsBitmap();
    iInvertedBitmap->Create(iSize, EGray2);
  
    InitializeL();

    SetActiveFadeEffect(EEffectNone);
    }

// -----------------------------------------------------------------------------
// CAknIndicatorFader::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CAknIndicatorFader* CAknIndicatorFader::NewL(TSize aSize)
    {
    CAknIndicatorFader* self = 
        new (ELeave) CAknIndicatorFader(aSize);
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop(); // self
    return self;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CAknIndicatorFader::~CAknIndicatorFader()
    {
    delete iFadedBitmap;
    delete iFaderDevice;
    delete iFaderGc;

    delete iFadingBitmap;
    delete iFadingDevice;
    delete iFadingGc;

    delete iInvertingBitmap;
    delete iInvertingDevice;
    delete iInvertingGc;
    
    delete iInvertedBitmap;
    delete iInvertedDevice;
    delete iInvertedGc;

    }

CFbsBitmap* CAknIndicatorFader::FadeMask(CFbsBitmap* aOriginalMask) const
    {
    if (aOriginalMask &&
        iActiveEffect != EEffectNone &&
        Initialized())
        {
        CFbsBitmap* usedMask = aOriginalMask;
        TDisplayMode displayMode = aOriginalMask->DisplayMode();
        TSize size = aOriginalMask->SizeInPixels();
        TRect rect = TRect(0,0,size.iWidth, size.iHeight);       
        TRgb rgbValue = 0x00000000;        

         // If given mask is hardmask, it must inverted.            
        if (displayMode == EGray2)
            {
            // clear the area first
            iInvertedGc->SetPenStyle(CGraphicsContext::ENullPen);
            iInvertedGc->SetBrushStyle(CGraphicsContext::ESolidBrush);    
            iInvertedGc->SetBrushColor(KRgbWhite);    
            iInvertedGc->DrawRect(TRect(TPoint(0,0), iSize));

            iInvertedGc->BitBltMasked(TPoint(0,0),
                iInvertingBitmap,
                rect,
                aOriginalMask,
                EFalse); 
            usedMask = iInvertedBitmap;
            }

        rgbValue = 0x00000000;
        for (TInt x=0; x < iSize.iWidth; x++)
            {
            iFaderGc->SetPenColor(TRgb(rgbValue));
            iFaderGc->DrawLine(TPoint(x,0), TPoint(x,iSize.iHeight));
            }

        iFaderGc->BitBltMasked(TPoint(0,0),
            iFadingBitmap,
            rect,
            usedMask,
            EFalse);        

        return iFadedBitmap;
        }
    else
        {
        return aOriginalMask;
        }

    }


void CAknIndicatorFader::SetActiveFadeEffect(TInt aActiveEffect)
    {
    if (aActiveEffect == iActiveEffect)
        return;
    
    iActiveEffect = aActiveEffect;
    CreateEffect(aActiveEffect);
    }


void CAknIndicatorFader::CreateEffect(TInt aEffect)
    {
    if (!Initialized())
        return;

    switch (aEffect)
        {
        case EEffectFadeToLeft:
            {
            TInt KStartValue = 30;
            TInt KEndValue   = 90;

            TInt KMaxFadeSteps = KEndValue - KStartValue;
            TInt usedFadeStep = 0;
            
            if (iSize.iWidth < KMaxFadeSteps && 
                iSize.iWidth != 0)
                {
                usedFadeStep = KMaxFadeSteps/iSize.iWidth;
                }
            else
                {
                usedFadeStep = iSize.iWidth/KMaxFadeSteps;
                }

            TRgb rgb;
            rgb.SetRed(KStartValue);
            rgb.SetGreen(KStartValue);
            rgb.SetBlue(KStartValue);
            
            for (TInt x=0; x < iSize.iWidth;x++)
                {
                iFadingGc->SetPenColor(rgb);
                iFadingGc->DrawLine(TPoint(x,0), TPoint(x,iSize.iHeight));
                rgb.SetRed(rgb.Red() + usedFadeStep);
                rgb.SetGreen(rgb.Green() + usedFadeStep);
                rgb.SetBlue(rgb.Blue() + usedFadeStep);
                }
            
            break;
            }

        case EEffectFadeToRight:
            {
            TInt KStartValue = 30;
            TInt KEndValue   = 90;

            TInt KMaxFadeSteps = KEndValue - KStartValue;
            TInt usedFadeStep = 0;
            
            if (iSize.iWidth < KMaxFadeSteps && 
                iSize.iWidth != 0)
                {
                usedFadeStep = KMaxFadeSteps/iSize.iWidth;
                }
            else
                {
                usedFadeStep = iSize.iWidth/KMaxFadeSteps;
                }

            TRgb rgb;
            rgb.SetRed(KStartValue);
            rgb.SetGreen(KStartValue);
            rgb.SetBlue(KStartValue);

            for (TInt x=iSize.iWidth - 1; x >= 0;x--)
                {
                iFadingGc->SetPenColor(rgb);
                iFadingGc->DrawLine(TPoint(x,0), TPoint(x,iSize.iHeight));
                rgb.SetRed(rgb.Red() + usedFadeStep);
                rgb.SetGreen(rgb.Green() + usedFadeStep);
                rgb.SetBlue(rgb.Blue() + usedFadeStep);
                }
            break;
            }
        case EEffectNone:
        default:
            {
            break;
            }
        }

    }


void CAknIndicatorFader::SetActiveFadeSize(TSize aSize)
    {
    if (aSize == iSize)
        return;

    iSize = aSize;
    TRAP_IGNORE(InitializeL());
    CreateEffect(iActiveEffect);
    }

void CAknIndicatorFader::InitializeL()
    {
    iFadedBitmap->Resize(iSize);
    iFadingBitmap->Resize(iSize);
    iInvertingBitmap->Resize(iSize);
    iInvertedBitmap->Resize(iSize);    

    delete iFaderDevice;
    iFaderDevice = NULL;
    delete iFaderGc;
    iFaderGc = NULL;
    iFaderDevice = CFbsBitmapDevice::NewL( iFadedBitmap );
    iFaderDevice->CreateContext( iFaderGc );

    delete iFadingDevice; 
    iFadingDevice = NULL;
    delete iFadingGc;
    iFadingGc = NULL;
    iFadingDevice = CFbsBitmapDevice::NewL( iFadingBitmap );
    iFadingDevice->CreateContext( iFadingGc );
   
    delete iInvertingDevice;
    iInvertingDevice = NULL;
    delete iInvertingGc;
    iInvertingGc = NULL;
    iInvertingDevice = CFbsBitmapDevice::NewL( iInvertingBitmap );
    iInvertingDevice->CreateContext( iInvertingGc );
    
    delete iInvertedDevice;
    iInvertedDevice = NULL;
    delete iInvertedGc;
    iInvertedGc = NULL;
    iInvertedDevice = CFbsBitmapDevice::NewL( iInvertedBitmap );
    iInvertedDevice->CreateContext( iInvertedGc );

    if (Initialized())
        {
        iFadingGc->SetPenColor(KRgbGray);
        iFadingGc->SetPenStyle(CGraphicsContext::ESolidPen);
        iFadingGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
       
        iInvertingGc->SetPenStyle(CGraphicsContext::ENullPen);
        iInvertingGc->SetBrushStyle(CGraphicsContext::ESolidBrush);    
        iInvertingGc->SetBrushColor(KRgbBlack);    
        iInvertingGc->DrawRect(TRect(TPoint(0,0), iSize));
        }
    }

TBool CAknIndicatorFader::Initialized() const
    {
    if (iFadedBitmap &&
        iFaderDevice &&
        iFaderGc &&
        iFadingBitmap &&
        iFadingDevice &&
        iFadingGc &&
        iInvertingBitmap &&
        iInvertingDevice &&
        iInvertingGc &&
        iInvertedBitmap &&
        iInvertedDevice &&
        iInvertedGc)
        {
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }