/*

* 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:  Class for buffer processor.

*

*/

#ifndef CMIDBUFFERPROCESSOR_H

#define CMIDBUFFERPROCESSOR_H

#include <lcdui.h>

#include "CMIDImage.h"

#include "TMIDBitmapParameters.h"

// FORWARD DECLARATIONS

class CMIDDirectGraphics;

class CMIDGraphics;

class CMIDToolkit;

NONSHARABLE_CLASS(CMIDBufferProcessor): public CBase,

        public MMIDBufferProcessor, public MMIDComponent

{

public: // Construction

    static void NewL(CMIDToolkit* aToolkit, TInt* aHandle,

    CMIDGraphics* aGraphics, MMIDImage* aImage);

public: // Destructor

    ~CMIDBufferProcessor();

public: // From MMIDComponent

    void Dispose();

    TType Type() const;

    MMIDBufferProcessor* Processor();

public:// From MMIDBufferProcessor

#ifdef RD_JAVA_NGA_ENABLED

    TBool ProcessL(const TMIDBufferOp*& aBegin,

                   const TMIDBufferOp* aEnd, TInt& aCycles, java::util::Monitor* aMonitor);

#else

    TBool ProcessL(const TMIDBufferOp*& aBegin,

                   const TMIDBufferOp* aEnd, TInt& aCycles, TRequestStatus* aStatus = NULL);

#endif

    void  AbortAsync();

public: // data

    // Owned

    CMIDDirectGraphics* iDirectGraphics;

    // Not owned

    CMIDGraphics* iGraphics;

protected: // Construction

    CMIDBufferProcessor();

    void ConstructL(CMIDGraphics* aGraphics, MMIDImage* aImage);

private:

    enum

    {

        EDrawTriangle = 102,

        EFillTriangle = 103,

        EDrawImage = 104

    };

    class TClipData

    {

    public:

        TPoint iTl;

        TSize iSize;

    };

    class TTriangleData

    {

    public:

        TInt x1;

        TInt y1;

        TInt x2;

        TInt y2;

        TInt x3;

        TInt y3;

        TInt color;

    };

    class TDirectImageData

    {

    public:

        TInt    iImage;

        TPoint  iPoint;

        TInt    iAnchor;

        TInt    iManipulation;

    };

    inline const TTriangleData& TriangleData(const TMIDBufferOp* aOp);

    inline const TRect RectData(const TMIDBufferOp* aOp);

    inline void UnlockedBitmapParameters(TMIDBitmapParameters& aParams,

                                         const TMIDBufferOp* aOp);

    inline void LockedBitmapParameters(TMIDBitmapParameters& aParams);

    /**

     * Draws image

     * @param aRead contains the image information

     * @param aUtil is used for locking the target bitmap

     */

    void DrawImageL(const TMIDBufferOp* aRead,

                    TBitmapUtil& aUtil);

    /**

     * Draws image. All bitmaps must be locked before calling this.

     * @param aParams contains the image information

     * @param aSourceUtil is used for locking the source bitmap

     * @param aTargetUtil is used for locking the target bitmap

     */

    void LockedDrawImageL(TMIDBitmapParameters& aParams,

                          TBitmapUtil& aSourceUtil,

                          TBitmapUtil& aTargetUtil);

    void DrawTriangle(const TTriangleData& aTriangle);

    void FillTriangle(const TTriangleData& aTriangle);

    void SetClipRect(const TRect& aRect);

};

template<class T>

inline const T& OpData(const TMIDBufferOp* aOp)

{

    ASSERT(aOp->Size() >= TInt(1 + (sizeof(T)/sizeof(TMIDBufferOp))));

    return *static_cast<const T*>(aOp->Data());

}

inline const CMIDBufferProcessor::TTriangleData&

CMIDBufferProcessor::TriangleData(const TMIDBufferOp* aOp)

{

    return OpData<CMIDBufferProcessor::TTriangleData>(aOp);

}

inline void

CMIDBufferProcessor::UnlockedBitmapParameters(TMIDBitmapParameters& aParams,

        const TMIDBufferOp* aOp)

{

    TDirectImageData imageData = OpData<CMIDBufferProcessor::TDirectImageData>(aOp);

    MMIDImage* image = MIDUnhandObject< MMIDImage >(imageData.iImage);

    // note: getting bitmap image increases its reference count

    MMIDBitmapImage* bitmapImage = image->BitmapImage();

    aParams.iBitmap = bitmapImage->ColorBitmap();

    CFbsBitmap* alphaBitmap = bitmapImage->AlphaBitmap();

    if (alphaBitmap)

    {

        aParams.iTransparency = ETrue;

        alphaBitmap->LockHeap();

        aParams.iAlpha = alphaBitmap->DataAddress();

        aParams.iAlphaMode = alphaBitmap->DisplayMode();

        TSize bitmapSize(alphaBitmap->SizeInPixels());

        TInt scanLineLength =

            CFbsBitmap::ScanLineLength(bitmapSize.iWidth,

                                       alphaBitmap->DisplayMode());

        TInt bitsPerPixel = alphaBitmap->Header().iBitsPerPixel;

        scanLineLength = (scanLineLength << 3) / bitsPerPixel;

        aParams.iAlphaSize = (scanLineLength * bitmapSize.iHeight *

                              bitsPerPixel) >> 3;

        alphaBitmap->UnlockHeap();

    }

    aParams.iManipulation = imageData.iManipulation;

    aParams.iAnchor = imageData.iAnchor;

    aParams.iX = imageData.iPoint.iX;

    aParams.iY = imageData.iPoint.iY;

    bitmapImage->RemoveRef();

}

inline void

CMIDBufferProcessor::LockedBitmapParameters(TMIDBitmapParameters& aParams)

{

    TSize bitmapSize(aParams.iBitmap->SizeInPixels());

    aParams.iWidth = bitmapSize.iWidth;

    aParams.iHeight = bitmapSize.iHeight;

    aParams.iScanLength =

        CFbsBitmap::ScanLineLength(bitmapSize.iWidth,

                                   aParams.iBitmap->DisplayMode());

    aParams.iScanLength = (aParams.iScanLength << 3) /

                          aParams.iBitmap->Header().iBitsPerPixel;

    aParams.iPixels = aParams.iBitmap->DataAddress();

    aParams.iPixelsSize = (aParams.iScanLength *

                           bitmapSize.iHeight *

                           aParams.iBitmap->Header().iBitsPerPixel) >> 3;

}

inline const TRect CMIDBufferProcessor::RectData(const TMIDBufferOp* aOp)

{

    const TClipData& clipData = OpData< TClipData >(aOp);

    const TRect clipRect(clipData.iTl, clipData.iSize);

    return clipRect;

}

#endif // CMIDBUFFERPROCESSOR_H