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



#include "CMIDBufferProcessor.h"
#include "CMIDDirectGraphics.h"
#include "CMIDToolkit.h"
#include "CMIDGraphics.h"
#include "CMIDConvertFactory.h"

// -----------------------------------------------------------------------------
// CMIDBufferProcessor::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
void CMIDBufferProcessor::NewL(CMIDToolkit* aToolkit,
                               TInt* aHandle, CMIDGraphics* aGraphics,
                               MMIDImage* aImage)
{
    CMIDBufferProcessor* processor = new(ELeave) CMIDBufferProcessor();
    CleanupStack::PushL(processor);
    processor->ConstructL(aGraphics, aImage);
    *aHandle = aToolkit->RegisterComponentL(processor, NULL);
    CleanupStack::Pop(processor);
}

CMIDBufferProcessor::CMIDBufferProcessor()
{
}

// -----------------------------------------------------------------------------
// CMIDBufferProcessor::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CMIDBufferProcessor::ConstructL(CMIDGraphics* aGraphics,
                                     MMIDImage* aImage)
{
    iGraphics = aGraphics;
    iDirectGraphics = CMIDDirectGraphics::NewL(aGraphics, aImage);
}

CMIDBufferProcessor::~CMIDBufferProcessor()
{
    delete iDirectGraphics;
}

void CMIDBufferProcessor::Dispose()
{
    delete this;
}

MMIDComponent::TType CMIDBufferProcessor::Type() const
{
    return EUnknown;
}

MMIDBufferProcessor* CMIDBufferProcessor::Processor()
{
    return this;
}

LOCAL_C void EndBitmapUtil(TAny* aBitmapUtil)
{
    ((TBitmapUtil*)aBitmapUtil)->End();
}

TBool CMIDBufferProcessor::ProcessL(
    const TMIDBufferOp*& aRead,
    const TMIDBufferOp* aEnd,
    TInt& aCycles,
#ifdef RD_JAVA_NGA_ENABLED
    java::util::Monitor* /*aMonitor*/)
#else
    TRequestStatus* /*aStatus*/)
#endif
{
    TBitmapUtil bitmapUtil(iGraphics->Bitmap());
    CleanupStack::PushL(TCleanupItem(&EndBitmapUtil,
                                     &bitmapUtil));
    bitmapUtil.Begin(TPoint(0, 0));

    while ((aRead < aEnd) && (aCycles > 0))
    {
        TInt opCode = aRead->OpCode();
        switch (opCode)
        {
        case MMIDGraphics::EGrOpSetClipRect:
        {
            SetClipRect(RectData(aRead));
            break;
        }
        case EDrawTriangle:
        {
            DrawTriangle(TriangleData(aRead));
            break;
        }
        case EFillTriangle:
        {
            FillTriangle(TriangleData(aRead));
            break;
        }
        case EDrawImage:
        {
            DrawImageL(aRead, bitmapUtil);
            break;
        }
        default:
        {
            bitmapUtil.End();
            ASSERT(EFalse);
            break;
        }
        }
        aRead += aRead->Size();
    }
    CleanupStack::Pop();   // CSI: 12 TCleanupItem parameter cannot be used with Pop #
    bitmapUtil.End();
    return EFalse;
}

void CMIDBufferProcessor::AbortAsync()
{
}

void CMIDBufferProcessor::DrawImageL(
    const TMIDBufferOp* aRead,
    TBitmapUtil& aUtil)
{
    TMIDBitmapParameters params;

    params.iTransparency = EFalse;

    UnlockedBitmapParameters(params, aRead);

    params.iFormat =
        CMIDConvertFactory::GetPixelFormat(params.iBitmap->DisplayMode());
    if ((params.iFormat == KMIDTypeInt8888ARGB) ||
            (params.iFormat == KMIDTypeUshort4444ARGB))
    {
        params.iTransparency = ETrue;
    }

    // if target and source bitmaps are in the same heap, locking the source
    // would result in a deadlock if target is locked.
    aUtil.End();

    TBitmapUtil imageBitmapUtil(params.iBitmap);
    CleanupStack::PushL(TCleanupItem(&EndBitmapUtil, &imageBitmapUtil));
    imageBitmapUtil.Begin(TPoint(0, 0), aUtil);

    LockedDrawImageL(params, imageBitmapUtil, aUtil);

    CleanupStack::PopAndDestroy();   // CSI: 12 TCleanupItem parameter cannot be used with PopAndDestroy #
}

void CMIDBufferProcessor::LockedDrawImageL(
    TMIDBitmapParameters& aParams,
    TBitmapUtil& aSourceUtil,
    TBitmapUtil& aTargetUtil)
{
    LockedBitmapParameters(aParams);
    // when we go to directgraphics code, target bitmap must be locked.
    // source must be unlocked in order to be sure that no deadlock occurs
    aSourceUtil.End();
    aTargetUtil.Begin(TPoint(0, 0), aSourceUtil);
    iDirectGraphics->DrawBitmapL(&aParams);
}


void CMIDBufferProcessor::DrawTriangle(const TTriangleData& aTriangle)
{
    iDirectGraphics->DrawTriangle(aTriangle.x1, aTriangle.y1, aTriangle.x2, aTriangle.y2,
                                  aTriangle.x3, aTriangle.y3, aTriangle.color);
}

void CMIDBufferProcessor::FillTriangle(const TTriangleData& aTriangle)
{
    iDirectGraphics->FillTriangle(aTriangle.x1, aTriangle.y1, aTriangle.x2, aTriangle.y2,
                                  aTriangle.x3, aTriangle.y3, aTriangle.color);
}

void CMIDBufferProcessor::SetClipRect(const TRect& aRect)
{
    iDirectGraphics->SetClippingRect(aRect);
}