/*

* Copyright (c) 2006-2007 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:  Abstract base class for format converters.

*

*/

//  INCLUDE FILES

#include "TMIDFormatConverter.h"

#include "TMIDGray1.h"

#include <fbs.h>

namespace

{

const TInt KAnchorHCenter = 1;

const TInt KAnchorVCenter = 2;

const TInt KAnchorRight = 8;

const TInt KAnchorBottom = 32;

const TInt KScanLengthOffset = 31;

const TInt KScanLengthDivider = 32;

}

TMIDFormatConverter::TMIDFormatConverter()

{

    iTransformer = TMIDTransformer();

    iBitmapRect = TRect();

    iOffset = 0;

    iScanlength = 0;

    iAlphaBitmap = NULL;

    iAlphaMode = ENone;

    iTransparency = ETrue;

}

void TMIDFormatConverter::InitializeL(const TMIDBitmapParameters& aParameters)

{

    iOffset = aParameters.iOffset;

    iScanlength = aParameters.iScanLength;

    iAlphaBitmap = aParameters.iAlpha;

    iAlphaMode = aParameters.iAlphaMode;

    iTransparency = aParameters.iTransparency;

    switch (iAlphaMode)

    {

    case EGray2:

    {

        iAlphaScanLength = ((aParameters.iWidth + KScanLengthOffset) /

                            KScanLengthDivider);

        break;

    }

    default:

    {

        if (iAlphaBitmap)

        {

            iAlphaScanLength = aParameters.iBitmap->ScanLineLength(

                                   aParameters.iWidth, iAlphaMode);

        }

    }

    }

    TInt lastPixel = iScanlength * (aParameters.iHeight - 1) +

                     aParameters.iWidth - 1 + iOffset;

    // checking that bitmap is big enough

    if (iOffset < 0 ||

            !CheckSize(aParameters.iPixelsSize, lastPixel))

    {

        // out of bounds

        User::Leave(KErrArrayIndexOutOfBoundsException);

    }

    // checking alpha size

    if (iAlphaBitmap)

    {

        if (((iAlphaMode == EGray256) &&

                (aParameters.iAlphaSize <

                 (aParameters.iHeight * aParameters.iWidth + iOffset))) ||

                ((iAlphaMode == EGray2) &&

                 (aParameters.iAlphaSize <

                  (aParameters.iHeight * (aParameters.iWidth >> KMIDShift3Bits)

                   + iOffset))) ||

                ((iAlphaMode != EGray256) && (iAlphaMode != EGray2) &&

                 (!CheckSize(aParameters.iAlphaSize, lastPixel))))

        {

            // out of bounds

            User::Leave(KErrArrayIndexOutOfBoundsException);

        }

    }

    iBitmapRect = TRect(aParameters.iX, aParameters.iY,

                        aParameters.iX + aParameters.iWidth,

                        aParameters.iY + aParameters.iHeight);

    // initializing transformer, this will only rotate

    iTransformer.Transform(iBitmapRect, aParameters.iManipulation);

    // calculating new position from anchor point

    if (aParameters.iAnchor != 0)

    {

        if (aParameters.iAnchor & KAnchorRight)

        {

            iBitmapRect.Move(-iBitmapRect.Width(), 0);

        }

        if (aParameters.iAnchor & KAnchorBottom)

        {

            iBitmapRect.Move(0, -iBitmapRect.Height());

        }

        if (aParameters.iAnchor & KAnchorHCenter)

        {

            iBitmapRect.Move(-(iBitmapRect.Width() >> 1), 0);

        }

        if (aParameters.iAnchor & KAnchorVCenter)

        {

            iBitmapRect.Move(0, -(iBitmapRect.Height() >> 1));

        }

    }

    // second phase of initialization, this will do actual initalization of directions

    // for both flip and rotate. Movement value is for changing starting position if out

    // of clipping rect.

    TPoint move(0, 0);

    if (iBitmapRect.iTl.iX < aParameters.iClipRect.iTl.iX)

    {

        move.iX = aParameters.iClipRect.iTl.iX - iBitmapRect.iTl.iX;

    }

    if (iBitmapRect.iTl.iY < aParameters.iClipRect.iTl.iY)

    {

        move.iY = aParameters.iClipRect.iTl.iY - iBitmapRect.iTl.iY;

    }

    // This will rotate and flip bitmap, returns error code if manipulation is

    // invalid

    User::LeaveIfError(iTransformer.Transform(move));

    // calculating possible new size after clipping

    iBitmapRect.Intersection(aParameters.iClipRect);

    if (iBitmapRect.IsEmpty())

    {

        // we are not in clipping rect, cancelling the drawing

        return;

    }

    // iTransformers moves are two dimensional moves with following combinations

    // x-move y-move

    // (1, 0) (0, 1) Default (no rotations or flips)

    // (1, 0) (0,-1)

    // (-1,0) (0, 1)

    // (-1,0) (0,-1)

    // (0, 1) (1, 0)

    // (0, 1) (-1,0)

    // (0,-1) (1, 0)

    // (0,-1) (-1,0)

    // So precalculating moves

    // going right or left when advancing y

    // x(y) y(x)

    //(1)   (1)  -scan * (height - 1) + 1

    //(1)   (-1) -scan * (height - 1) - 1

    //(-1)  (1)   scan * (height - 1) + 1

    //(-1)  (-1)  scan * (height - 1) - 1

    if (iTransformer.iYMove.iX != 0)

    {

        iTransformer.iYMove.iX += (-(iTransformer.iXMove.iY) * iScanlength) *

                                  (iBitmapRect.Width() - 1);

    }

    // going up or down when advancing x

    iTransformer.iXMove.iY *= iScanlength;

    // going up or down (default) when advancing y

    // x    y

    //(1)   (1)  scan - width + 1

    //(-1)  (1)  scan + width - 1

    //(1)   (-1) -scan - width + 1

    //(-1)  (-1) -scan + width - 1

    iTransformer.iYMove.iY = iTransformer.iYMove.iY * iScanlength -

                             (iTransformer.iXMove.iX * iBitmapRect.Width()) + iTransformer.iXMove.iX;

    // combine x & y to one value

    iTransformer.iXMove.iX += iTransformer.iXMove.iY;

    iTransformer.iYMove.iX += iTransformer.iYMove.iY;

}

void TMIDFormatConverter::GetPixelWithAlpha(TMIDInternalARGB& aResult) const

{

    GetPixel(aResult);

    switch (iAlphaMode)

    {

    case(EGray256):

    {

        TInt line = iOffset / iScanlength;

        TInt column = iOffset % iScanlength;

        aResult.iA =

            ((TUint8*)iAlphaBitmap)[ line * iAlphaScanLength + column ];  // CSI: 2 Wrong index means implementation error #

        break;

    }

    case(EGray2):

    {

        TInt line = iOffset / iScanlength;

        TInt column = iOffset % iScanlength;

        TInt word = line * iAlphaScanLength + (column >> KMIDShift5Bits);

        aResult.iA = (((((TUint32*)iAlphaBitmap)[ word ] >>    // CSI: 2 Wrong index means implementation error #

                        (column % KScanLengthDivider)) & 1) * KAlphaFullOpaque);

        break;

    }

    default:

    {

        aResult.iA = GetAlpha();

    }

    }

}

void TMIDFormatConverter::PlotPixelWithAlpha(const TMIDInternalARGB& aInternal)

{

    PlotPixel(aInternal);

    // modifying alpha channel

    if (iAlphaBitmap)

    {

        switch (iAlphaMode)

        {

        case(EGray256):

        {

            TInt line = iOffset / iScanlength;

            TInt column = iOffset % iScanlength;

            ((TUint8*)iAlphaBitmap)[ line * iAlphaScanLength + column ] =  // CSI: 2 Wrong index means implementation error #

                aInternal.iA;

            break;

        }

        case(EGray2):

        {

            TInt line = iOffset / iScanlength;

            TInt column = iOffset % iScanlength;

            TInt word = line * iAlphaScanLength + (column >> KMIDShift5Bits);

            if ((aInternal.iR + aInternal.iG + aInternal.iB) <

                    KWhiteBlackSumRGBMidValue)

            {

                iAlphaBitmap[ word ] = (TUint32)(iAlphaBitmap[ word ] |      // CSI: 2 Wrong offset means implementation error #

                                                 KBits32[ column % KScanLengthDivider ]);   // CSI: 2 Wrong index means implementation error #

            }

            else

            {

                iAlphaBitmap[ word ] = (TUint32)(iAlphaBitmap[ word ] &     // CSI: 2 Wrong offset means implementation error #

                                                 ~KBits32[ column % KScanLengthDivider ]);   // CSI: 2 Wrong index means implementation error #

            }

        }

        default:

        {

            // otherwise we have same format as normal bitmap

            // getting real bitmap from converter

            TUint32* tempBitmap = Bitmap();

            SetBitmap(iAlphaBitmap);

            // It must be either white or black

            TMIDInternalARGB alphaIn;

            if (aInternal.iA == KAlphaFullOpaque)

            {

                alphaIn = KOpaque;

            }

            PlotPixel(alphaIn);

            // reverting to original bitmap

            SetBitmap(tempBitmap);

        }

        }

    }

}

TBool TMIDFormatConverter::IsAlpha()

{

    if (iAlphaBitmap)

    {

        return ETrue;

    }

    return EFalse;

}