/*
* 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:  1 bit format, 2 distinct color values, stored as a byte.
*
*/


//  INCLUDE FILES
#include "TMIDGray1.h"

namespace
{
const TUint8 KWhite = 0;
const TUint8 KBlack = 1;
const TInt KMIDOffSet = 7;
}

void TMIDGray1::InitializeL(const TMIDBitmapParameters& aParameters)
{
    TMIDFormatConverter::InitializeL(aParameters);
    iOffset += iTransformer.iPoint.iX + iTransformer.iPoint.iY * iScanlength;
    iBitmap = (TUint8*)aParameters.iPixels;
}

TUint32 TMIDGray1::ConvertInternal(const TMIDInternalARGB& aInternal)
{
    if ((aInternal.iR + aInternal.iG + aInternal.iB)  <
            KWhiteBlackSumRGBMidValue)
    {
        // return 'on' (black)
        return KBlack;
    }
    else
    {
        // return 'off' (white)
        return KWhite;
    }
}

void TMIDGray1::Convert(TMIDInternalARGB& aResult, TUint32 aColor) const
{
    aResult.iA = KAlphaFullOpaque;
    if (aColor == KWhite)
    {
        aResult.iR = KAlphaFullOpaque;
        aResult.iG = KAlphaFullOpaque;
        aResult.iB = KAlphaFullOpaque;
    }
    else
    {
        aResult.iR = 0;
        aResult.iG = 0;
        aResult.iB = 0;
    }
}


void TMIDGray1::GetPixel(TMIDInternalARGB& aResult) const
{
    Convert(aResult, (iBitmap[ iOffset >> KGray1Shift ] >>     // CSI: 2 Wrong index means implementation error #
                      (KMIDOffSet - (iOffset % KPixelsInByteGray1))) & 1);
}

TUint8 TMIDGray1::GetAlpha() const
{
    return (TUint8)(((((TUint8*)iAlphaBitmap)[ iOffset >> KGray1Shift ] >>          // CSI: 2 Wrong index means implementation error #
                      (KMIDOffSet - (iOffset % KPixelsInByteGray1))) & 1) *
                    KAlphaFullOpaque);
}

void TMIDGray1::PlotPixel(const TMIDInternalARGB& aInternal)
{
    if (ConvertInternal(aInternal) == KBlack)
    {
        // black
        iBitmap[ iOffset >> KGray1Shift ] = // CSI: 2 Wrong index means implementation error #
            (TUint8)(iBitmap[ iOffset >> KGray1Shift ] |     // CSI: 2 Wrong index means implementation error #
                     KBits[ iOffset % KPixelsInByteGray1 ]);  // CSI: 2 Wrong index means implementation error #
    }
    else
    {
        // white
        iBitmap[ iOffset >> KGray1Shift ] =   // CSI: 2 Wrong index means implementation error #
            (TUint8)(iBitmap[ iOffset >> KGray1Shift ] &     // CSI: 2 Wrong index means implementation error #
                     ~KBits[ iOffset % KPixelsInByteGray1 ]);   // CSI: 2 Wrong index means implementation error #
    }
}

void TMIDGray1::PlotPixelWithAlpha(const TMIDInternalARGB& aInternal)
{
    PlotPixel(aInternal);

    // modifying alpha channel
    if (iAlphaBitmap)
    {
        if (iAlphaMode == EGray256)
        {
            ((TUint8*)iAlphaBitmap)[ iOffset ] = aInternal.iA;     // CSI: 2 Wrong index means implementation error #
        }
        else
        {
            // 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
            // NOTE: This is just opposite way than
            // normal alpha since 0 (black) is 'on'
            // and 1 (white) is 'off'
            TMIDInternalARGB alphaIn;
            if (aInternal.iA != KAlphaFullOpaque)
            {
                alphaIn = KOpaque;
            }
            PlotPixel(alphaIn);

            // reverting to original bitmap
            SetBitmap(tempBitmap);
        }
    }
}

TBool TMIDGray1::CheckSize(TInt aPixelSize, TInt aLastDrawnPixelOffset)
{
    if (aLastDrawnPixelOffset <= aPixelSize * KPixelsInByteGray1)
    {
        return ETrue; // there's enough space
    }
    return EFalse; // there's not enough space
}